#![feature(prelude_import)]
#![feature(generic_const_exprs)]
#![feature(slice_as_chunks)]
#![feature(portable_simd)]
#![feature(avx512_target_feature)]
//! This is the main entry point of the lib
//! We materialized all types that could be usefull
//! As we have 64 of them (32 for u64 type and 32 for u128)
//! we use seq! macro to generate all that in a concise way.
//!
//! To expose novel code, add a new module and integrate it belows.
#![allow(non_local_definitions)]
#[prelude_import]
use std::prelude::rust_2021::*;
#[macro_use]
extern crate std;
use crate::pydna::{PyDNA, PyNucleotid};
use crate::pyindex::*;
use crate::pykmer::*;
use paste::paste;
use pyo3::exceptions::{PyKeyError, PyValueError};
use pyo3::prelude::*;
use pyo3::types::{PyBytes, PyIterator, PyString, PyTuple, PyType};
use seq_macro::seq;
use std::env;
use std::path::Path;
use std::simd::Simd;
use std::mem::transmute;
use vizitig_lib::iterators::{CanonicalKmerIterator, KmerIterator};
use vizitig_lib::kmer::Kmer;
use vizitig_lib::kmer_index::{IndexIterator, KmerIndex, KmerIndexEntry};
use vizitig_lib::kmer_simd::SimdDataStore;
pub mod pybigkmer {
    pub(crate) use bigkmer;
}
pub mod pydna {
    use pyo3::exceptions::PyValueError;
    use pyo3::prelude::*;
    use pyo3::types::{PyString, PyType};
    use vizitig_lib::dna::{Nucleotid, DNA};
    pub struct PyNucleotid(pub Nucleotid);
    #[automatically_derived]
    impl ::core::clone::Clone for PyNucleotid {
        #[inline]
        fn clone(&self) -> PyNucleotid {
            PyNucleotid(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for PyNucleotid {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for PyNucleotid {
        const NAME: &'static str = "PyNucleotid";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <PyNucleotid as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for PyNucleotid {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a PyNucleotid {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, PyNucleotid>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut PyNucleotid {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, PyNucleotid>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for PyNucleotid {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for PyNucleotid {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<PyNucleotid>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for PyNucleotid {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<PyNucleotid>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<PyNucleotid> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl PyNucleotid {}
    impl PyNucleotid {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl PyNucleotid {}
    impl PyNucleotid {
        fn from_char(
            _: &Bound<'_, PyType>,
            input: &Bound<'_, PyString>,
        ) -> PyResult<Self> {
            let input_str = input.to_str()?;
            match input_str.len() {
                1 => Ok(Self(input_str.chars().next().unwrap().try_into().unwrap())),
                _ => Err(PyValueError::new_err("Input str is not a char (len>1)")),
            }
        }
        fn from_u8(_: &Bound<'_, PyType>, input: u8) -> PyResult<Self> {
            Ok(Self(input.try_into().unwrap()))
        }
        fn __str__(&self) -> PyResult<String> {
            Ok(
                ::alloc::__export::must_use({
                    let res = ::alloc::fmt::format(format_args!("{0}", self.0));
                    res
                }),
            )
        }
        fn __repr__(&self) -> PyResult<String> {
            Ok(
                ::alloc::__export::must_use({
                    let res = ::alloc::fmt::format(
                        format_args!("Nucleotid<{0}>", self.0),
                    );
                    res
                }),
            )
        }
        fn complement(&self) -> PyResult<Self> {
            Ok(Self(self.0.complement()))
        }
        fn __add__(&self, other: &Bound<'_, PyAny>) -> PyResult<PyDNA> {
            let n1: Nucleotid = self.0;
            let n2: Nucleotid = other.extract::<Self>()?.0;
            Ok(PyDNA(DNA(<[_]>::into_vec(::alloc::boxed::box_new([n1, n2])))))
        }
    }
    impl PyNucleotid {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___add____(
            py: ::pyo3::Python,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyNucleotid::__add__(
                match ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    PyNucleotid,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                ) {
                    ::std::result::Result::Ok(value) => value,
                    ::std::result::Result::Err(_) => {
                        return ::pyo3::impl_::callback::convert(py, py.NotImplemented());
                    }
                },
                match ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "other",
                ) {
                    ::std::result::Result::Ok(value) => value,
                    ::std::result::Result::Err(_) => {
                        return ::pyo3::impl_::callback::convert(py, py.NotImplemented());
                    }
                },
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    impl ::pyo3::impl_::pyclass::PyClass__add__SlotFragment<PyNucleotid>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<PyNucleotid> {
        #[inline]
        unsafe fn __add__(
            self,
            py: ::pyo3::Python,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            PyNucleotid::__pymethod___add____(py, _raw_slf, arg0)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<PyNucleotid>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<PyNucleotid> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"from_char",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                PyNucleotid::__pymethod_from_char__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"from_char($cls, input)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"from_u8",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                PyNucleotid::__pymethod_from_u8__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"from_u8($cls, input)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                c"complement",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        unsafe {
                                            ::pyo3::impl_::trampoline::noargs(
                                                _slf,
                                                _args,
                                                PyNucleotid::__pymethod_complement__,
                                            )
                                        }
                                    }
                                    trampoline
                                },
                                c"complement($self)\n--\n\n",
                            ),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::reprfunc(
                                _slf,
                                PyNucleotid::__pymethod___str____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_str,
                            pfunc: trampoline as ::pyo3::ffi::reprfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::reprfunc(
                                _slf,
                                PyNucleotid::__pymethod___repr____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_repr,
                            pfunc: trampoline as ::pyo3::ffi::reprfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn __wrap(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            _other: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                _other,
                                |py, _slf, _other| {
                                    use ::pyo3::impl_::pyclass::*;
                                    let collector = PyClassImplCollector::<PyNucleotid>::new();
                                    let lhs_result = collector.__add__(py, _slf, _other)?;
                                    if lhs_result == ::pyo3::ffi::Py_NotImplemented() {
                                        ::pyo3::ffi::Py_DECREF(lhs_result);
                                        collector.__radd__(py, _other, _slf)
                                    } else {
                                        ::std::result::Result::Ok(lhs_result)
                                    }
                                },
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_nb_add,
                            pfunc: __wrap as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl PyNucleotid {
        unsafe fn __pymethod_from_char__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyNucleotid::from_char;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyNucleotid as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "from_char",
                positional_parameter_names: &["input"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "input",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_from_u8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyNucleotid::from_u8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyNucleotid as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "from_u8",
                positional_parameter_names: &["input"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "input",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___str____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyNucleotid::__str__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyNucleotid::__str__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    PyNucleotid,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___repr____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyNucleotid::__repr__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyNucleotid::__repr__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    PyNucleotid,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod_complement__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyNucleotid::complement;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyNucleotid,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_0,
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
    }
    /// A class wrapper around a DNA struct from vizicomp
    pub struct PyDNA(pub DNA);
    #[automatically_derived]
    impl ::core::clone::Clone for PyDNA {
        #[inline]
        fn clone(&self) -> PyDNA {
            PyDNA(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for PyDNA {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for PyDNA {
        const NAME: &'static str = "PyDNA";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <PyDNA as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for PyDNA {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a PyDNA {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, PyDNA>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut PyDNA {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, PyDNA>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for PyDNA {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for PyDNA {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<PyDNA>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for PyDNA {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<PyDNA>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"A class wrapper around a DNA struct from vizicomp",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<PyDNA> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl PyDNA {}
    impl PyDNA {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl PyDNA {}
    impl PyDNA {
        pub fn new(input_pystr: &Bound<'_, PyString>) -> PyResult<Self> {
            let input_str = input_pystr.to_str()?;
            let dna = input_str.as_bytes().try_into().unwrap();
            Ok(PyDNA(dna))
        }
        pub fn __repr__(&self) -> PyResult<String> {
            Ok(
                ::alloc::__export::must_use({
                    let res = ::alloc::fmt::format(
                        format_args!("RustDNA<{0}>", self.__str__().unwrap()),
                    );
                    res
                }),
            )
        }
        pub fn __str__(&self) -> PyResult<String> {
            let repr: String = self.0.0.clone().into_iter().map(char::from).collect();
            Ok(repr)
        }
        fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.0.len())
        }
        /// get the Nucleotid as a char at a given index
        pub fn get_index(&self, index: usize) -> PyResult<PyNucleotid> {
            Ok(PyNucleotid(self.0.0[index]))
        }
        /// get a slice of the DNA
        pub fn get_slice(&self, start: usize, stop: usize) -> PyResult<Self> {
            Ok(PyDNA(DNA(self.0.0.get(start..stop).unwrap().to_vec())))
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<PyDNA>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<PyDNA> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"get_index",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            PyDNA::__pymethod_get_index__,
                                        )
                                    }
                                    trampoline
                                },
                                c"get_index($self, index)\n--\n\nget the Nucleotid as a char at a given index",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"get_slice",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            PyDNA::__pymethod_get_slice__,
                                        )
                                    }
                                    trampoline
                                },
                                c"get_slice($self, start, stop)\n--\n\nget a slice of the DNA",
                            ),
                        ),
                    ),
                ],
                slots: &[
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<PyDNA>
                                for PyClassImplCollector<PyDNA> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(input_pystr)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    PyDNA::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::reprfunc(
                                _slf,
                                PyDNA::__pymethod___repr____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_repr,
                            pfunc: trampoline as ::pyo3::ffi::reprfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::reprfunc(
                                _slf,
                                PyDNA::__pymethod___str____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_str,
                            pfunc: trampoline as ::pyo3::ffi::reprfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                PyDNA::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl PyDNA {
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = PyDNA::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyDNA as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["input_pystr"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyDNA::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "input_pystr",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<PyDNA> = result.convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___repr____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyDNA::__repr__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyDNA::__repr__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    PyDNA,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___str____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyDNA::__str__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyDNA::__str__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    PyDNA,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = PyDNA::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyDNA::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    PyDNA,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod_get_index__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyDNA::get_index;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyDNA as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "get_index",
                positional_parameter_names: &["index"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyDNA,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "index",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_get_slice__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyDNA::get_slice;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyDNA as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "get_slice",
                positional_parameter_names: &["start", "stop"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 2usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 2usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyDNA,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_2,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "start",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "stop",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
    }
}
pub mod pyindex {
    use paste::paste;
    use pyo3::exceptions::PyKeyError;
    use pyo3::prelude::*;
    use pyo3::types::{PyIterator, PyString, PyType};
    use std::path::Path;
    use vizitig_lib::kmer_index::{Index, IndexEntry, IndexIterator};
    pub struct IndexIteratoru8u8(IndexIterator<u8, u8>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratoru8u8 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratoru8u8 {
        const NAME: &'static str = "IndexIteratoru8u8";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratoru8u8 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratoru8u8 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratoru8u8 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratoru8u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratoru8u8 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratoru8u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratoru8u8 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratoru8u8 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratoru8u8>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratoru8u8 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IndexIteratoru8u8>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratoru8u8> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru8u8 {}
    impl IndexIteratoru8u8 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru8u8 {}
    impl IndexIteratoru8u8 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(u8, u8)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((index_entry.key, index_entry.val.try_into().unwrap()))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratoru8u8>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratoru8u8> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratoru8u8::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratoru8u8::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru8u8 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru8u8::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratoru8u8::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru8u8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru8u8::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratoru8u8::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru8u8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntIndexu8u8(pub Index<u8, u8>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntIndexu8u8 {
        #[inline]
        fn clone(&self) -> IntIndexu8u8 {
            IntIndexu8u8(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntIndexu8u8 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntIndexu8u8 {
        const NAME: &'static str = "IntIndexu8u8";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntIndexu8u8 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntIndexu8u8 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntIndexu8u8 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntIndexu8u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntIndexu8u8 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntIndexu8u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntIndexu8u8 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntIndexu8u8 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntIndexu8u8>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntIndexu8u8 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntIndexu8u8>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntIndexu8u8> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu8u8 {}
    impl IntIndexu8u8 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu8u8 {}
    impl IntIndexu8u8 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u8, u8> {
                            key: i.getattr("key")?.extract::<u8>().unwrap(),
                            val: i.getattr("val")?.extract::<u8>().unwrap(),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u8,
                        u8,
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u8) -> PyResult<u8> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u8, u8>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratoru8u8>> {
            let iter = IndexIteratoru8u8(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntIndexu8u8>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntIndexu8u8> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntIndexu8u8::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntIndexu8u8::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntIndexu8u8::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntIndexu8u8>
                                for PyClassImplCollector<IntIndexu8u8> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntIndexu8u8::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntIndexu8u8::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu8u8 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu8u8::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu8u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntIndexu8u8::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu8u8::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu8u8,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu8u8::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu8u8::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu8u8,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntIndexu8u8::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu8u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu8u8::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntIndexu8u8> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu8u8::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntIndexu8u8::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntIndexu8u8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratoru8u16(IndexIterator<u8, u16>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratoru8u16 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratoru8u16 {
        const NAME: &'static str = "IndexIteratoru8u16";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratoru8u16 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratoru8u16 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratoru8u16 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratoru8u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratoru8u16 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratoru8u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratoru8u16 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratoru8u16 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratoru8u16>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratoru8u16 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IndexIteratoru8u16>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratoru8u16> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru8u16 {}
    impl IndexIteratoru8u16 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru8u16 {}
    impl IndexIteratoru8u16 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(u8, u16)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((index_entry.key, index_entry.val.try_into().unwrap()))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratoru8u16>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratoru8u16> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratoru8u16::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratoru8u16::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru8u16 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru8u16::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratoru8u16::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru8u16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru8u16::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratoru8u16::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru8u16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntIndexu8u16(pub Index<u8, u16>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntIndexu8u16 {
        #[inline]
        fn clone(&self) -> IntIndexu8u16 {
            IntIndexu8u16(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntIndexu8u16 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntIndexu8u16 {
        const NAME: &'static str = "IntIndexu8u16";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntIndexu8u16 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntIndexu8u16 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntIndexu8u16 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntIndexu8u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntIndexu8u16 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntIndexu8u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntIndexu8u16 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntIndexu8u16 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntIndexu8u16>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntIndexu8u16 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntIndexu8u16>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntIndexu8u16> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu8u16 {}
    impl IntIndexu8u16 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu8u16 {}
    impl IntIndexu8u16 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u8, u16> {
                            key: i.getattr("key")?.extract::<u8>().unwrap(),
                            val: i.getattr("val")?.extract::<u16>().unwrap(),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u8,
                        u16,
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u8) -> PyResult<u16> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u8, u16>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratoru8u16>> {
            let iter = IndexIteratoru8u16(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntIndexu8u16>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntIndexu8u16> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntIndexu8u16::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntIndexu8u16::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntIndexu8u16::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntIndexu8u16>
                                for PyClassImplCollector<IntIndexu8u16> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntIndexu8u16::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntIndexu8u16::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu8u16 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu8u16::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu8u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntIndexu8u16::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu8u16::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu8u16,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu8u16::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu8u16::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu8u16,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntIndexu8u16::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu8u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu8u16::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntIndexu8u16> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu8u16::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntIndexu8u16::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntIndexu8u16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratoru8u32(IndexIterator<u8, u32>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratoru8u32 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratoru8u32 {
        const NAME: &'static str = "IndexIteratoru8u32";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratoru8u32 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratoru8u32 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratoru8u32 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratoru8u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratoru8u32 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratoru8u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratoru8u32 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratoru8u32 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratoru8u32>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratoru8u32 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IndexIteratoru8u32>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratoru8u32> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru8u32 {}
    impl IndexIteratoru8u32 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru8u32 {}
    impl IndexIteratoru8u32 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(u8, u32)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((index_entry.key, index_entry.val.try_into().unwrap()))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratoru8u32>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratoru8u32> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratoru8u32::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratoru8u32::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru8u32 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru8u32::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratoru8u32::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru8u32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru8u32::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratoru8u32::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru8u32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntIndexu8u32(pub Index<u8, u32>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntIndexu8u32 {
        #[inline]
        fn clone(&self) -> IntIndexu8u32 {
            IntIndexu8u32(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntIndexu8u32 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntIndexu8u32 {
        const NAME: &'static str = "IntIndexu8u32";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntIndexu8u32 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntIndexu8u32 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntIndexu8u32 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntIndexu8u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntIndexu8u32 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntIndexu8u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntIndexu8u32 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntIndexu8u32 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntIndexu8u32>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntIndexu8u32 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntIndexu8u32>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntIndexu8u32> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu8u32 {}
    impl IntIndexu8u32 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu8u32 {}
    impl IntIndexu8u32 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u8, u32> {
                            key: i.getattr("key")?.extract::<u8>().unwrap(),
                            val: i.getattr("val")?.extract::<u32>().unwrap(),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u8,
                        u32,
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u8) -> PyResult<u32> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u8, u32>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratoru8u32>> {
            let iter = IndexIteratoru8u32(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntIndexu8u32>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntIndexu8u32> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntIndexu8u32::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntIndexu8u32::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntIndexu8u32::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntIndexu8u32>
                                for PyClassImplCollector<IntIndexu8u32> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntIndexu8u32::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntIndexu8u32::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu8u32 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu8u32::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu8u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntIndexu8u32::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu8u32::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu8u32,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu8u32::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu8u32::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu8u32,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntIndexu8u32::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu8u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu8u32::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntIndexu8u32> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu8u32::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntIndexu8u32::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntIndexu8u32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratoru8u64(IndexIterator<u8, u64>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratoru8u64 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratoru8u64 {
        const NAME: &'static str = "IndexIteratoru8u64";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratoru8u64 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratoru8u64 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratoru8u64 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratoru8u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratoru8u64 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratoru8u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratoru8u64 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratoru8u64 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratoru8u64>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratoru8u64 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IndexIteratoru8u64>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratoru8u64> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru8u64 {}
    impl IndexIteratoru8u64 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru8u64 {}
    impl IndexIteratoru8u64 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(u8, u64)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((index_entry.key, index_entry.val.try_into().unwrap()))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratoru8u64>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratoru8u64> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratoru8u64::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratoru8u64::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru8u64 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru8u64::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratoru8u64::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru8u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru8u64::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratoru8u64::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru8u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntIndexu8u64(pub Index<u8, u64>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntIndexu8u64 {
        #[inline]
        fn clone(&self) -> IntIndexu8u64 {
            IntIndexu8u64(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntIndexu8u64 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntIndexu8u64 {
        const NAME: &'static str = "IntIndexu8u64";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntIndexu8u64 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntIndexu8u64 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntIndexu8u64 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntIndexu8u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntIndexu8u64 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntIndexu8u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntIndexu8u64 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntIndexu8u64 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntIndexu8u64>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntIndexu8u64 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntIndexu8u64>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntIndexu8u64> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu8u64 {}
    impl IntIndexu8u64 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu8u64 {}
    impl IntIndexu8u64 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u8, u64> {
                            key: i.getattr("key")?.extract::<u8>().unwrap(),
                            val: i.getattr("val")?.extract::<u64>().unwrap(),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u8,
                        u64,
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u8) -> PyResult<u64> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u8, u64>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratoru8u64>> {
            let iter = IndexIteratoru8u64(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntIndexu8u64>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntIndexu8u64> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntIndexu8u64::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntIndexu8u64::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntIndexu8u64::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntIndexu8u64>
                                for PyClassImplCollector<IntIndexu8u64> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntIndexu8u64::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntIndexu8u64::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu8u64 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu8u64::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu8u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntIndexu8u64::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu8u64::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu8u64,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu8u64::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu8u64::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu8u64,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntIndexu8u64::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu8u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu8u64::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntIndexu8u64> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu8u64::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntIndexu8u64::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntIndexu8u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratoru8u128(IndexIterator<u8, u128>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratoru8u128 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratoru8u128 {
        const NAME: &'static str = "IndexIteratoru8u128";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratoru8u128 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratoru8u128 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratoru8u128 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratoru8u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratoru8u128 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratoru8u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratoru8u128 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratoru8u128 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratoru8u128>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratoru8u128 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIteratoru8u128,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratoru8u128> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru8u128 {}
    impl IndexIteratoru8u128 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru8u128 {}
    impl IndexIteratoru8u128 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(u8, u128)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((index_entry.key, index_entry.val.try_into().unwrap()))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratoru8u128>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratoru8u128> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratoru8u128::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratoru8u128::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru8u128 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru8u128::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratoru8u128::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru8u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru8u128::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratoru8u128::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru8u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntIndexu8u128(pub Index<u8, u128>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntIndexu8u128 {
        #[inline]
        fn clone(&self) -> IntIndexu8u128 {
            IntIndexu8u128(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntIndexu8u128 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntIndexu8u128 {
        const NAME: &'static str = "IntIndexu8u128";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntIndexu8u128 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntIndexu8u128 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntIndexu8u128 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntIndexu8u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntIndexu8u128 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntIndexu8u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntIndexu8u128 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntIndexu8u128 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntIndexu8u128>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntIndexu8u128 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntIndexu8u128>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntIndexu8u128> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu8u128 {}
    impl IntIndexu8u128 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu8u128 {}
    impl IntIndexu8u128 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u8, u128> {
                            key: i.getattr("key")?.extract::<u8>().unwrap(),
                            val: i.getattr("val")?.extract::<u128>().unwrap(),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u8,
                        u128,
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u8) -> PyResult<u128> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u8, u128>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratoru8u128>> {
            let iter = IndexIteratoru8u128(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntIndexu8u128>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntIndexu8u128> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntIndexu8u128::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntIndexu8u128::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntIndexu8u128::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntIndexu8u128>
                                for PyClassImplCollector<IntIndexu8u128> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntIndexu8u128::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntIndexu8u128::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu8u128 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu8u128::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu8u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntIndexu8u128::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu8u128::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu8u128,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu8u128::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu8u128::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu8u128,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntIndexu8u128::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu8u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu8u128::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntIndexu8u128> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu8u128::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntIndexu8u128::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntIndexu8u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratorSetu8(pub IndexIterator<u8, ()>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratorSetu8 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratorSetu8 {
        const NAME: &'static str = "IndexIteratorSetu8";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratorSetu8 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratorSetu8 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratorSetu8 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratorSetu8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratorSetu8 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratorSetu8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratorSetu8 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratorSetu8 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratorSetu8>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratorSetu8 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IndexIteratorSetu8>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratorSetu8> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratorSetu8 {}
    impl IndexIteratorSetu8 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratorSetu8 {}
    impl IndexIteratorSetu8 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<u8> {
            match slf.0.next() {
                Some(index_entry) => Some(index_entry.key),
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratorSetu8>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratorSetu8> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratorSetu8::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratorSetu8::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratorSetu8 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratorSetu8::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratorSetu8::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratorSetu8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratorSetu8::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratorSetu8::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratorSetu8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntSetu8(pub Index<u8, ()>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntSetu8 {
        #[inline]
        fn clone(&self) -> IntSetu8 {
            IntSetu8(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntSetu8 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntSetu8 {
        const NAME: &'static str = "IntSetu8";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntSetu8 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntSetu8 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntSetu8 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntSetu8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntSetu8 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntSetu8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntSetu8 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntSetu8 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntSetu8>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntSetu8 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntSetu8>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntSetu8> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntSetu8 {}
    impl IntSetu8 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntSetu8 {}
    impl IntSetu8 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u8, ()> {
                            key: i.getattr("key")?.extract::<u8>().unwrap(),
                            val: (),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u8,
                        (),
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u8) -> PyResult<()> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        pub fn __contains__(&self, key: u8) -> PyResult<bool> {
            match self.0.get(key) {
                Ok(_) => Ok(true),
                _ => Ok(false),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u8, ()>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratorSetu8>> {
            let iter = IndexIteratorSetu8(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntSetu8>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntSetu8> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntSetu8::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntSetu8::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntSetu8::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> ::std::os::raw::c_int {
                            ::pyo3::impl_::trampoline::objobjproc(
                                _slf,
                                arg0,
                                IntSetu8::__pymethod___contains____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_sq_contains,
                            pfunc: trampoline as ::pyo3::ffi::objobjproc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntSetu8>
                                for PyClassImplCollector<IntSetu8> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntSetu8::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntSetu8::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntSetu8 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntSetu8::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntSetu8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntSetu8::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntSetu8::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntSetu8,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntSetu8::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntSetu8::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntSetu8,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___contains____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::std::os::raw::c_int> {
            let function = IntSetu8::__contains__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntSetu8::__contains__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntSetu8,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntSetu8::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntSetu8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntSetu8::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntSetu8> = result.convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntSetu8::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntSetu8::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntSetu8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratoru16u8(IndexIterator<u16, u8>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratoru16u8 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratoru16u8 {
        const NAME: &'static str = "IndexIteratoru16u8";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratoru16u8 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratoru16u8 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratoru16u8 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratoru16u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratoru16u8 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratoru16u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratoru16u8 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratoru16u8 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratoru16u8>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratoru16u8 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IndexIteratoru16u8>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratoru16u8> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru16u8 {}
    impl IndexIteratoru16u8 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru16u8 {}
    impl IndexIteratoru16u8 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(u16, u8)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((index_entry.key, index_entry.val.try_into().unwrap()))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratoru16u8>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratoru16u8> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratoru16u8::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratoru16u8::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru16u8 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru16u8::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratoru16u8::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru16u8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru16u8::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratoru16u8::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru16u8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntIndexu16u8(pub Index<u16, u8>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntIndexu16u8 {
        #[inline]
        fn clone(&self) -> IntIndexu16u8 {
            IntIndexu16u8(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntIndexu16u8 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntIndexu16u8 {
        const NAME: &'static str = "IntIndexu16u8";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntIndexu16u8 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntIndexu16u8 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntIndexu16u8 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntIndexu16u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntIndexu16u8 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntIndexu16u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntIndexu16u8 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntIndexu16u8 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntIndexu16u8>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntIndexu16u8 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntIndexu16u8>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntIndexu16u8> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu16u8 {}
    impl IntIndexu16u8 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu16u8 {}
    impl IntIndexu16u8 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u16, u8> {
                            key: i.getattr("key")?.extract::<u16>().unwrap(),
                            val: i.getattr("val")?.extract::<u8>().unwrap(),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u16,
                        u8,
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u16) -> PyResult<u8> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u16, u8>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratoru16u8>> {
            let iter = IndexIteratoru16u8(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntIndexu16u8>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntIndexu16u8> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntIndexu16u8::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntIndexu16u8::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntIndexu16u8::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntIndexu16u8>
                                for PyClassImplCollector<IntIndexu16u8> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntIndexu16u8::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntIndexu16u8::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu16u8 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu16u8::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu16u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntIndexu16u8::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu16u8::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu16u8,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu16u8::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu16u8::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu16u8,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntIndexu16u8::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu16u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu16u8::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntIndexu16u8> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu16u8::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntIndexu16u8::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntIndexu16u8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratoru16u16(IndexIterator<u16, u16>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratoru16u16 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratoru16u16 {
        const NAME: &'static str = "IndexIteratoru16u16";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratoru16u16 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratoru16u16 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratoru16u16 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratoru16u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratoru16u16 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratoru16u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratoru16u16 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratoru16u16 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratoru16u16>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratoru16u16 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIteratoru16u16,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratoru16u16> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru16u16 {}
    impl IndexIteratoru16u16 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru16u16 {}
    impl IndexIteratoru16u16 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(u16, u16)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((index_entry.key, index_entry.val.try_into().unwrap()))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratoru16u16>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratoru16u16> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratoru16u16::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratoru16u16::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru16u16 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru16u16::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratoru16u16::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru16u16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru16u16::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratoru16u16::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru16u16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntIndexu16u16(pub Index<u16, u16>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntIndexu16u16 {
        #[inline]
        fn clone(&self) -> IntIndexu16u16 {
            IntIndexu16u16(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntIndexu16u16 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntIndexu16u16 {
        const NAME: &'static str = "IntIndexu16u16";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntIndexu16u16 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntIndexu16u16 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntIndexu16u16 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntIndexu16u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntIndexu16u16 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntIndexu16u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntIndexu16u16 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntIndexu16u16 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntIndexu16u16>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntIndexu16u16 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntIndexu16u16>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntIndexu16u16> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu16u16 {}
    impl IntIndexu16u16 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu16u16 {}
    impl IntIndexu16u16 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u16, u16> {
                            key: i.getattr("key")?.extract::<u16>().unwrap(),
                            val: i.getattr("val")?.extract::<u16>().unwrap(),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u16,
                        u16,
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u16) -> PyResult<u16> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u16, u16>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratoru16u16>> {
            let iter = IndexIteratoru16u16(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntIndexu16u16>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntIndexu16u16> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntIndexu16u16::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntIndexu16u16::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntIndexu16u16::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntIndexu16u16>
                                for PyClassImplCollector<IntIndexu16u16> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntIndexu16u16::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntIndexu16u16::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu16u16 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu16u16::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu16u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntIndexu16u16::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu16u16::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu16u16,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu16u16::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu16u16::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu16u16,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntIndexu16u16::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu16u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu16u16::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntIndexu16u16> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu16u16::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntIndexu16u16::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntIndexu16u16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratoru16u32(IndexIterator<u16, u32>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratoru16u32 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratoru16u32 {
        const NAME: &'static str = "IndexIteratoru16u32";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratoru16u32 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratoru16u32 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratoru16u32 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratoru16u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratoru16u32 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratoru16u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratoru16u32 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratoru16u32 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratoru16u32>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratoru16u32 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIteratoru16u32,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratoru16u32> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru16u32 {}
    impl IndexIteratoru16u32 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru16u32 {}
    impl IndexIteratoru16u32 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(u16, u32)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((index_entry.key, index_entry.val.try_into().unwrap()))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratoru16u32>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratoru16u32> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratoru16u32::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratoru16u32::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru16u32 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru16u32::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratoru16u32::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru16u32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru16u32::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratoru16u32::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru16u32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntIndexu16u32(pub Index<u16, u32>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntIndexu16u32 {
        #[inline]
        fn clone(&self) -> IntIndexu16u32 {
            IntIndexu16u32(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntIndexu16u32 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntIndexu16u32 {
        const NAME: &'static str = "IntIndexu16u32";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntIndexu16u32 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntIndexu16u32 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntIndexu16u32 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntIndexu16u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntIndexu16u32 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntIndexu16u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntIndexu16u32 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntIndexu16u32 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntIndexu16u32>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntIndexu16u32 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntIndexu16u32>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntIndexu16u32> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu16u32 {}
    impl IntIndexu16u32 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu16u32 {}
    impl IntIndexu16u32 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u16, u32> {
                            key: i.getattr("key")?.extract::<u16>().unwrap(),
                            val: i.getattr("val")?.extract::<u32>().unwrap(),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u16,
                        u32,
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u16) -> PyResult<u32> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u16, u32>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratoru16u32>> {
            let iter = IndexIteratoru16u32(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntIndexu16u32>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntIndexu16u32> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntIndexu16u32::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntIndexu16u32::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntIndexu16u32::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntIndexu16u32>
                                for PyClassImplCollector<IntIndexu16u32> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntIndexu16u32::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntIndexu16u32::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu16u32 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu16u32::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu16u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntIndexu16u32::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu16u32::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu16u32,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu16u32::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu16u32::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu16u32,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntIndexu16u32::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu16u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu16u32::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntIndexu16u32> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu16u32::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntIndexu16u32::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntIndexu16u32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratoru16u64(IndexIterator<u16, u64>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratoru16u64 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratoru16u64 {
        const NAME: &'static str = "IndexIteratoru16u64";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratoru16u64 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratoru16u64 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratoru16u64 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratoru16u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratoru16u64 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratoru16u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratoru16u64 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratoru16u64 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratoru16u64>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratoru16u64 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIteratoru16u64,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratoru16u64> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru16u64 {}
    impl IndexIteratoru16u64 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru16u64 {}
    impl IndexIteratoru16u64 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(u16, u64)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((index_entry.key, index_entry.val.try_into().unwrap()))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratoru16u64>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratoru16u64> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratoru16u64::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratoru16u64::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru16u64 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru16u64::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratoru16u64::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru16u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru16u64::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratoru16u64::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru16u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntIndexu16u64(pub Index<u16, u64>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntIndexu16u64 {
        #[inline]
        fn clone(&self) -> IntIndexu16u64 {
            IntIndexu16u64(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntIndexu16u64 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntIndexu16u64 {
        const NAME: &'static str = "IntIndexu16u64";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntIndexu16u64 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntIndexu16u64 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntIndexu16u64 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntIndexu16u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntIndexu16u64 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntIndexu16u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntIndexu16u64 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntIndexu16u64 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntIndexu16u64>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntIndexu16u64 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntIndexu16u64>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntIndexu16u64> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu16u64 {}
    impl IntIndexu16u64 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu16u64 {}
    impl IntIndexu16u64 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u16, u64> {
                            key: i.getattr("key")?.extract::<u16>().unwrap(),
                            val: i.getattr("val")?.extract::<u64>().unwrap(),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u16,
                        u64,
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u16) -> PyResult<u64> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u16, u64>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratoru16u64>> {
            let iter = IndexIteratoru16u64(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntIndexu16u64>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntIndexu16u64> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntIndexu16u64::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntIndexu16u64::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntIndexu16u64::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntIndexu16u64>
                                for PyClassImplCollector<IntIndexu16u64> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntIndexu16u64::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntIndexu16u64::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu16u64 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu16u64::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu16u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntIndexu16u64::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu16u64::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu16u64,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu16u64::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu16u64::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu16u64,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntIndexu16u64::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu16u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu16u64::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntIndexu16u64> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu16u64::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntIndexu16u64::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntIndexu16u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratoru16u128(IndexIterator<u16, u128>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratoru16u128 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratoru16u128 {
        const NAME: &'static str = "IndexIteratoru16u128";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratoru16u128 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratoru16u128 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratoru16u128 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratoru16u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratoru16u128 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratoru16u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratoru16u128 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratoru16u128 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratoru16u128>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratoru16u128 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIteratoru16u128,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratoru16u128> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru16u128 {}
    impl IndexIteratoru16u128 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru16u128 {}
    impl IndexIteratoru16u128 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(u16, u128)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((index_entry.key, index_entry.val.try_into().unwrap()))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratoru16u128>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratoru16u128> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratoru16u128::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratoru16u128::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru16u128 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru16u128::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratoru16u128::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru16u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru16u128::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratoru16u128::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru16u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntIndexu16u128(pub Index<u16, u128>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntIndexu16u128 {
        #[inline]
        fn clone(&self) -> IntIndexu16u128 {
            IntIndexu16u128(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntIndexu16u128 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntIndexu16u128 {
        const NAME: &'static str = "IntIndexu16u128";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntIndexu16u128 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntIndexu16u128 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntIndexu16u128 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntIndexu16u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntIndexu16u128 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntIndexu16u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntIndexu16u128 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntIndexu16u128 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntIndexu16u128>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntIndexu16u128 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntIndexu16u128>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntIndexu16u128> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu16u128 {}
    impl IntIndexu16u128 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu16u128 {}
    impl IntIndexu16u128 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u16, u128> {
                            key: i.getattr("key")?.extract::<u16>().unwrap(),
                            val: i.getattr("val")?.extract::<u128>().unwrap(),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u16,
                        u128,
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u16) -> PyResult<u128> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u16, u128>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratoru16u128>> {
            let iter = IndexIteratoru16u128(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntIndexu16u128>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntIndexu16u128> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntIndexu16u128::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntIndexu16u128::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntIndexu16u128::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntIndexu16u128>
                                for PyClassImplCollector<IntIndexu16u128> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntIndexu16u128::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntIndexu16u128::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu16u128 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu16u128::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu16u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntIndexu16u128::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu16u128::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu16u128,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu16u128::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu16u128::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu16u128,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntIndexu16u128::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu16u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu16u128::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntIndexu16u128> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu16u128::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntIndexu16u128::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntIndexu16u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratorSetu16(pub IndexIterator<u16, ()>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratorSetu16 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratorSetu16 {
        const NAME: &'static str = "IndexIteratorSetu16";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratorSetu16 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratorSetu16 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratorSetu16 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratorSetu16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratorSetu16 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratorSetu16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratorSetu16 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratorSetu16 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratorSetu16>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratorSetu16 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIteratorSetu16,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratorSetu16> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratorSetu16 {}
    impl IndexIteratorSetu16 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratorSetu16 {}
    impl IndexIteratorSetu16 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<u16> {
            match slf.0.next() {
                Some(index_entry) => Some(index_entry.key),
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratorSetu16>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratorSetu16> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratorSetu16::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratorSetu16::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratorSetu16 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratorSetu16::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratorSetu16::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratorSetu16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratorSetu16::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratorSetu16::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratorSetu16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntSetu16(pub Index<u16, ()>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntSetu16 {
        #[inline]
        fn clone(&self) -> IntSetu16 {
            IntSetu16(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntSetu16 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntSetu16 {
        const NAME: &'static str = "IntSetu16";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntSetu16 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntSetu16 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntSetu16 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntSetu16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntSetu16 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntSetu16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntSetu16 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntSetu16 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntSetu16>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntSetu16 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntSetu16>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntSetu16> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntSetu16 {}
    impl IntSetu16 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntSetu16 {}
    impl IntSetu16 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u16, ()> {
                            key: i.getattr("key")?.extract::<u16>().unwrap(),
                            val: (),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u16,
                        (),
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u16) -> PyResult<()> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        pub fn __contains__(&self, key: u16) -> PyResult<bool> {
            match self.0.get(key) {
                Ok(_) => Ok(true),
                _ => Ok(false),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u16, ()>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratorSetu16>> {
            let iter = IndexIteratorSetu16(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntSetu16>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntSetu16> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntSetu16::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntSetu16::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntSetu16::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> ::std::os::raw::c_int {
                            ::pyo3::impl_::trampoline::objobjproc(
                                _slf,
                                arg0,
                                IntSetu16::__pymethod___contains____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_sq_contains,
                            pfunc: trampoline as ::pyo3::ffi::objobjproc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntSetu16>
                                for PyClassImplCollector<IntSetu16> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntSetu16::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntSetu16::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntSetu16 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntSetu16::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntSetu16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntSetu16::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntSetu16::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntSetu16,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntSetu16::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntSetu16::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntSetu16,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___contains____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::std::os::raw::c_int> {
            let function = IntSetu16::__contains__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntSetu16::__contains__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntSetu16,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntSetu16::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntSetu16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntSetu16::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntSetu16> = result.convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntSetu16::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntSetu16::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntSetu16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratoru32u8(IndexIterator<u32, u8>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratoru32u8 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratoru32u8 {
        const NAME: &'static str = "IndexIteratoru32u8";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratoru32u8 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratoru32u8 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratoru32u8 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratoru32u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratoru32u8 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratoru32u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratoru32u8 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratoru32u8 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratoru32u8>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratoru32u8 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IndexIteratoru32u8>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratoru32u8> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru32u8 {}
    impl IndexIteratoru32u8 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru32u8 {}
    impl IndexIteratoru32u8 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(u32, u8)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((index_entry.key, index_entry.val.try_into().unwrap()))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratoru32u8>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratoru32u8> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratoru32u8::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratoru32u8::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru32u8 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru32u8::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratoru32u8::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru32u8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru32u8::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratoru32u8::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru32u8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntIndexu32u8(pub Index<u32, u8>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntIndexu32u8 {
        #[inline]
        fn clone(&self) -> IntIndexu32u8 {
            IntIndexu32u8(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntIndexu32u8 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntIndexu32u8 {
        const NAME: &'static str = "IntIndexu32u8";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntIndexu32u8 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntIndexu32u8 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntIndexu32u8 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntIndexu32u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntIndexu32u8 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntIndexu32u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntIndexu32u8 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntIndexu32u8 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntIndexu32u8>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntIndexu32u8 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntIndexu32u8>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntIndexu32u8> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu32u8 {}
    impl IntIndexu32u8 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu32u8 {}
    impl IntIndexu32u8 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u32, u8> {
                            key: i.getattr("key")?.extract::<u32>().unwrap(),
                            val: i.getattr("val")?.extract::<u8>().unwrap(),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u32,
                        u8,
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u32) -> PyResult<u8> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u32, u8>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratoru32u8>> {
            let iter = IndexIteratoru32u8(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntIndexu32u8>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntIndexu32u8> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntIndexu32u8::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntIndexu32u8::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntIndexu32u8::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntIndexu32u8>
                                for PyClassImplCollector<IntIndexu32u8> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntIndexu32u8::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntIndexu32u8::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu32u8 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu32u8::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu32u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntIndexu32u8::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu32u8::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu32u8,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu32u8::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu32u8::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu32u8,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntIndexu32u8::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu32u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu32u8::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntIndexu32u8> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu32u8::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntIndexu32u8::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntIndexu32u8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratoru32u16(IndexIterator<u32, u16>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratoru32u16 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratoru32u16 {
        const NAME: &'static str = "IndexIteratoru32u16";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratoru32u16 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratoru32u16 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratoru32u16 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratoru32u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratoru32u16 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratoru32u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratoru32u16 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratoru32u16 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratoru32u16>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratoru32u16 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIteratoru32u16,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratoru32u16> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru32u16 {}
    impl IndexIteratoru32u16 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru32u16 {}
    impl IndexIteratoru32u16 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(u32, u16)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((index_entry.key, index_entry.val.try_into().unwrap()))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratoru32u16>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratoru32u16> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratoru32u16::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratoru32u16::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru32u16 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru32u16::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratoru32u16::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru32u16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru32u16::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratoru32u16::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru32u16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntIndexu32u16(pub Index<u32, u16>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntIndexu32u16 {
        #[inline]
        fn clone(&self) -> IntIndexu32u16 {
            IntIndexu32u16(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntIndexu32u16 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntIndexu32u16 {
        const NAME: &'static str = "IntIndexu32u16";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntIndexu32u16 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntIndexu32u16 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntIndexu32u16 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntIndexu32u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntIndexu32u16 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntIndexu32u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntIndexu32u16 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntIndexu32u16 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntIndexu32u16>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntIndexu32u16 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntIndexu32u16>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntIndexu32u16> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu32u16 {}
    impl IntIndexu32u16 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu32u16 {}
    impl IntIndexu32u16 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u32, u16> {
                            key: i.getattr("key")?.extract::<u32>().unwrap(),
                            val: i.getattr("val")?.extract::<u16>().unwrap(),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u32,
                        u16,
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u32) -> PyResult<u16> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u32, u16>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratoru32u16>> {
            let iter = IndexIteratoru32u16(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntIndexu32u16>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntIndexu32u16> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntIndexu32u16::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntIndexu32u16::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntIndexu32u16::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntIndexu32u16>
                                for PyClassImplCollector<IntIndexu32u16> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntIndexu32u16::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntIndexu32u16::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu32u16 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu32u16::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu32u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntIndexu32u16::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu32u16::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu32u16,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu32u16::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu32u16::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu32u16,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntIndexu32u16::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu32u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu32u16::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntIndexu32u16> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu32u16::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntIndexu32u16::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntIndexu32u16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratoru32u32(IndexIterator<u32, u32>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratoru32u32 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratoru32u32 {
        const NAME: &'static str = "IndexIteratoru32u32";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratoru32u32 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratoru32u32 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratoru32u32 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratoru32u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratoru32u32 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratoru32u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratoru32u32 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratoru32u32 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratoru32u32>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratoru32u32 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIteratoru32u32,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratoru32u32> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru32u32 {}
    impl IndexIteratoru32u32 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru32u32 {}
    impl IndexIteratoru32u32 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(u32, u32)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((index_entry.key, index_entry.val.try_into().unwrap()))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratoru32u32>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratoru32u32> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratoru32u32::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratoru32u32::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru32u32 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru32u32::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratoru32u32::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru32u32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru32u32::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratoru32u32::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru32u32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntIndexu32u32(pub Index<u32, u32>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntIndexu32u32 {
        #[inline]
        fn clone(&self) -> IntIndexu32u32 {
            IntIndexu32u32(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntIndexu32u32 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntIndexu32u32 {
        const NAME: &'static str = "IntIndexu32u32";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntIndexu32u32 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntIndexu32u32 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntIndexu32u32 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntIndexu32u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntIndexu32u32 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntIndexu32u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntIndexu32u32 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntIndexu32u32 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntIndexu32u32>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntIndexu32u32 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntIndexu32u32>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntIndexu32u32> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu32u32 {}
    impl IntIndexu32u32 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu32u32 {}
    impl IntIndexu32u32 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u32, u32> {
                            key: i.getattr("key")?.extract::<u32>().unwrap(),
                            val: i.getattr("val")?.extract::<u32>().unwrap(),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u32,
                        u32,
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u32) -> PyResult<u32> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u32, u32>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratoru32u32>> {
            let iter = IndexIteratoru32u32(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntIndexu32u32>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntIndexu32u32> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntIndexu32u32::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntIndexu32u32::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntIndexu32u32::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntIndexu32u32>
                                for PyClassImplCollector<IntIndexu32u32> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntIndexu32u32::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntIndexu32u32::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu32u32 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu32u32::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu32u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntIndexu32u32::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu32u32::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu32u32,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu32u32::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu32u32::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu32u32,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntIndexu32u32::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu32u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu32u32::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntIndexu32u32> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu32u32::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntIndexu32u32::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntIndexu32u32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratoru32u64(IndexIterator<u32, u64>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratoru32u64 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratoru32u64 {
        const NAME: &'static str = "IndexIteratoru32u64";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratoru32u64 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratoru32u64 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratoru32u64 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratoru32u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratoru32u64 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratoru32u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratoru32u64 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratoru32u64 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratoru32u64>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratoru32u64 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIteratoru32u64,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratoru32u64> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru32u64 {}
    impl IndexIteratoru32u64 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru32u64 {}
    impl IndexIteratoru32u64 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(u32, u64)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((index_entry.key, index_entry.val.try_into().unwrap()))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratoru32u64>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratoru32u64> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratoru32u64::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratoru32u64::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru32u64 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru32u64::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratoru32u64::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru32u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru32u64::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratoru32u64::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru32u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntIndexu32u64(pub Index<u32, u64>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntIndexu32u64 {
        #[inline]
        fn clone(&self) -> IntIndexu32u64 {
            IntIndexu32u64(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntIndexu32u64 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntIndexu32u64 {
        const NAME: &'static str = "IntIndexu32u64";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntIndexu32u64 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntIndexu32u64 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntIndexu32u64 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntIndexu32u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntIndexu32u64 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntIndexu32u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntIndexu32u64 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntIndexu32u64 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntIndexu32u64>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntIndexu32u64 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntIndexu32u64>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntIndexu32u64> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu32u64 {}
    impl IntIndexu32u64 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu32u64 {}
    impl IntIndexu32u64 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u32, u64> {
                            key: i.getattr("key")?.extract::<u32>().unwrap(),
                            val: i.getattr("val")?.extract::<u64>().unwrap(),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u32,
                        u64,
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u32) -> PyResult<u64> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u32, u64>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratoru32u64>> {
            let iter = IndexIteratoru32u64(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntIndexu32u64>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntIndexu32u64> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntIndexu32u64::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntIndexu32u64::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntIndexu32u64::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntIndexu32u64>
                                for PyClassImplCollector<IntIndexu32u64> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntIndexu32u64::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntIndexu32u64::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu32u64 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu32u64::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu32u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntIndexu32u64::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu32u64::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu32u64,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu32u64::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu32u64::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu32u64,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntIndexu32u64::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu32u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu32u64::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntIndexu32u64> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu32u64::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntIndexu32u64::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntIndexu32u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratoru32u128(IndexIterator<u32, u128>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratoru32u128 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratoru32u128 {
        const NAME: &'static str = "IndexIteratoru32u128";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratoru32u128 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratoru32u128 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratoru32u128 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratoru32u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratoru32u128 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratoru32u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratoru32u128 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratoru32u128 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratoru32u128>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratoru32u128 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIteratoru32u128,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratoru32u128> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru32u128 {}
    impl IndexIteratoru32u128 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru32u128 {}
    impl IndexIteratoru32u128 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(u32, u128)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((index_entry.key, index_entry.val.try_into().unwrap()))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratoru32u128>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratoru32u128> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratoru32u128::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratoru32u128::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru32u128 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru32u128::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratoru32u128::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru32u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru32u128::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratoru32u128::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru32u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntIndexu32u128(pub Index<u32, u128>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntIndexu32u128 {
        #[inline]
        fn clone(&self) -> IntIndexu32u128 {
            IntIndexu32u128(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntIndexu32u128 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntIndexu32u128 {
        const NAME: &'static str = "IntIndexu32u128";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntIndexu32u128 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntIndexu32u128 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntIndexu32u128 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntIndexu32u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntIndexu32u128 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntIndexu32u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntIndexu32u128 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntIndexu32u128 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntIndexu32u128>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntIndexu32u128 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntIndexu32u128>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntIndexu32u128> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu32u128 {}
    impl IntIndexu32u128 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu32u128 {}
    impl IntIndexu32u128 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u32, u128> {
                            key: i.getattr("key")?.extract::<u32>().unwrap(),
                            val: i.getattr("val")?.extract::<u128>().unwrap(),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u32,
                        u128,
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u32) -> PyResult<u128> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u32, u128>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratoru32u128>> {
            let iter = IndexIteratoru32u128(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntIndexu32u128>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntIndexu32u128> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntIndexu32u128::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntIndexu32u128::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntIndexu32u128::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntIndexu32u128>
                                for PyClassImplCollector<IntIndexu32u128> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntIndexu32u128::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntIndexu32u128::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu32u128 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu32u128::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu32u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntIndexu32u128::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu32u128::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu32u128,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu32u128::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu32u128::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu32u128,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntIndexu32u128::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu32u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu32u128::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntIndexu32u128> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu32u128::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntIndexu32u128::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntIndexu32u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratorSetu32(pub IndexIterator<u32, ()>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratorSetu32 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratorSetu32 {
        const NAME: &'static str = "IndexIteratorSetu32";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratorSetu32 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratorSetu32 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratorSetu32 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratorSetu32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratorSetu32 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratorSetu32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratorSetu32 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratorSetu32 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratorSetu32>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratorSetu32 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIteratorSetu32,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratorSetu32> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratorSetu32 {}
    impl IndexIteratorSetu32 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratorSetu32 {}
    impl IndexIteratorSetu32 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<u32> {
            match slf.0.next() {
                Some(index_entry) => Some(index_entry.key),
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratorSetu32>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratorSetu32> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratorSetu32::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratorSetu32::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratorSetu32 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratorSetu32::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratorSetu32::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratorSetu32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratorSetu32::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratorSetu32::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratorSetu32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntSetu32(pub Index<u32, ()>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntSetu32 {
        #[inline]
        fn clone(&self) -> IntSetu32 {
            IntSetu32(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntSetu32 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntSetu32 {
        const NAME: &'static str = "IntSetu32";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntSetu32 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntSetu32 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntSetu32 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntSetu32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntSetu32 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntSetu32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntSetu32 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntSetu32 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntSetu32>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntSetu32 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntSetu32>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntSetu32> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntSetu32 {}
    impl IntSetu32 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntSetu32 {}
    impl IntSetu32 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u32, ()> {
                            key: i.getattr("key")?.extract::<u32>().unwrap(),
                            val: (),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u32,
                        (),
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u32) -> PyResult<()> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        pub fn __contains__(&self, key: u32) -> PyResult<bool> {
            match self.0.get(key) {
                Ok(_) => Ok(true),
                _ => Ok(false),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u32, ()>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratorSetu32>> {
            let iter = IndexIteratorSetu32(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntSetu32>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntSetu32> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntSetu32::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntSetu32::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntSetu32::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> ::std::os::raw::c_int {
                            ::pyo3::impl_::trampoline::objobjproc(
                                _slf,
                                arg0,
                                IntSetu32::__pymethod___contains____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_sq_contains,
                            pfunc: trampoline as ::pyo3::ffi::objobjproc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntSetu32>
                                for PyClassImplCollector<IntSetu32> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntSetu32::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntSetu32::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntSetu32 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntSetu32::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntSetu32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntSetu32::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntSetu32::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntSetu32,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntSetu32::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntSetu32::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntSetu32,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___contains____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::std::os::raw::c_int> {
            let function = IntSetu32::__contains__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntSetu32::__contains__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntSetu32,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntSetu32::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntSetu32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntSetu32::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntSetu32> = result.convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntSetu32::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntSetu32::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntSetu32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratoru64u8(IndexIterator<u64, u8>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratoru64u8 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratoru64u8 {
        const NAME: &'static str = "IndexIteratoru64u8";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratoru64u8 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratoru64u8 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratoru64u8 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratoru64u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratoru64u8 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratoru64u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratoru64u8 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratoru64u8 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratoru64u8>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratoru64u8 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IndexIteratoru64u8>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratoru64u8> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru64u8 {}
    impl IndexIteratoru64u8 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru64u8 {}
    impl IndexIteratoru64u8 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(u64, u8)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((index_entry.key, index_entry.val.try_into().unwrap()))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratoru64u8>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratoru64u8> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratoru64u8::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratoru64u8::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru64u8 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru64u8::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratoru64u8::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru64u8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru64u8::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratoru64u8::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru64u8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntIndexu64u8(pub Index<u64, u8>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntIndexu64u8 {
        #[inline]
        fn clone(&self) -> IntIndexu64u8 {
            IntIndexu64u8(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntIndexu64u8 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntIndexu64u8 {
        const NAME: &'static str = "IntIndexu64u8";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntIndexu64u8 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntIndexu64u8 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntIndexu64u8 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntIndexu64u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntIndexu64u8 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntIndexu64u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntIndexu64u8 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntIndexu64u8 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntIndexu64u8>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntIndexu64u8 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntIndexu64u8>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntIndexu64u8> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu64u8 {}
    impl IntIndexu64u8 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu64u8 {}
    impl IntIndexu64u8 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u64, u8> {
                            key: i.getattr("key")?.extract::<u64>().unwrap(),
                            val: i.getattr("val")?.extract::<u8>().unwrap(),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u64,
                        u8,
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u64) -> PyResult<u8> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u64, u8>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratoru64u8>> {
            let iter = IndexIteratoru64u8(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntIndexu64u8>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntIndexu64u8> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntIndexu64u8::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntIndexu64u8::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntIndexu64u8::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntIndexu64u8>
                                for PyClassImplCollector<IntIndexu64u8> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntIndexu64u8::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntIndexu64u8::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu64u8 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu64u8::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu64u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntIndexu64u8::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu64u8::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu64u8,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu64u8::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu64u8::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu64u8,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntIndexu64u8::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu64u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu64u8::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntIndexu64u8> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu64u8::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntIndexu64u8::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntIndexu64u8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratoru64u16(IndexIterator<u64, u16>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratoru64u16 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratoru64u16 {
        const NAME: &'static str = "IndexIteratoru64u16";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratoru64u16 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratoru64u16 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratoru64u16 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratoru64u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratoru64u16 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratoru64u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratoru64u16 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratoru64u16 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratoru64u16>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratoru64u16 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIteratoru64u16,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratoru64u16> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru64u16 {}
    impl IndexIteratoru64u16 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru64u16 {}
    impl IndexIteratoru64u16 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(u64, u16)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((index_entry.key, index_entry.val.try_into().unwrap()))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratoru64u16>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratoru64u16> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratoru64u16::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratoru64u16::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru64u16 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru64u16::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratoru64u16::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru64u16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru64u16::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratoru64u16::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru64u16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntIndexu64u16(pub Index<u64, u16>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntIndexu64u16 {
        #[inline]
        fn clone(&self) -> IntIndexu64u16 {
            IntIndexu64u16(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntIndexu64u16 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntIndexu64u16 {
        const NAME: &'static str = "IntIndexu64u16";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntIndexu64u16 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntIndexu64u16 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntIndexu64u16 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntIndexu64u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntIndexu64u16 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntIndexu64u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntIndexu64u16 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntIndexu64u16 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntIndexu64u16>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntIndexu64u16 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntIndexu64u16>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntIndexu64u16> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu64u16 {}
    impl IntIndexu64u16 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu64u16 {}
    impl IntIndexu64u16 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u64, u16> {
                            key: i.getattr("key")?.extract::<u64>().unwrap(),
                            val: i.getattr("val")?.extract::<u16>().unwrap(),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u64,
                        u16,
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u64) -> PyResult<u16> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u64, u16>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratoru64u16>> {
            let iter = IndexIteratoru64u16(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntIndexu64u16>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntIndexu64u16> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntIndexu64u16::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntIndexu64u16::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntIndexu64u16::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntIndexu64u16>
                                for PyClassImplCollector<IntIndexu64u16> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntIndexu64u16::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntIndexu64u16::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu64u16 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu64u16::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu64u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntIndexu64u16::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu64u16::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu64u16,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu64u16::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu64u16::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu64u16,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntIndexu64u16::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu64u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu64u16::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntIndexu64u16> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu64u16::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntIndexu64u16::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntIndexu64u16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratoru64u32(IndexIterator<u64, u32>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratoru64u32 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratoru64u32 {
        const NAME: &'static str = "IndexIteratoru64u32";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratoru64u32 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratoru64u32 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratoru64u32 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratoru64u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratoru64u32 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratoru64u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratoru64u32 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratoru64u32 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratoru64u32>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratoru64u32 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIteratoru64u32,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratoru64u32> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru64u32 {}
    impl IndexIteratoru64u32 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru64u32 {}
    impl IndexIteratoru64u32 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(u64, u32)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((index_entry.key, index_entry.val.try_into().unwrap()))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratoru64u32>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratoru64u32> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratoru64u32::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratoru64u32::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru64u32 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru64u32::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratoru64u32::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru64u32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru64u32::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratoru64u32::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru64u32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntIndexu64u32(pub Index<u64, u32>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntIndexu64u32 {
        #[inline]
        fn clone(&self) -> IntIndexu64u32 {
            IntIndexu64u32(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntIndexu64u32 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntIndexu64u32 {
        const NAME: &'static str = "IntIndexu64u32";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntIndexu64u32 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntIndexu64u32 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntIndexu64u32 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntIndexu64u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntIndexu64u32 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntIndexu64u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntIndexu64u32 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntIndexu64u32 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntIndexu64u32>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntIndexu64u32 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntIndexu64u32>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntIndexu64u32> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu64u32 {}
    impl IntIndexu64u32 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu64u32 {}
    impl IntIndexu64u32 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u64, u32> {
                            key: i.getattr("key")?.extract::<u64>().unwrap(),
                            val: i.getattr("val")?.extract::<u32>().unwrap(),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u64,
                        u32,
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u64) -> PyResult<u32> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u64, u32>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratoru64u32>> {
            let iter = IndexIteratoru64u32(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntIndexu64u32>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntIndexu64u32> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntIndexu64u32::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntIndexu64u32::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntIndexu64u32::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntIndexu64u32>
                                for PyClassImplCollector<IntIndexu64u32> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntIndexu64u32::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntIndexu64u32::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu64u32 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu64u32::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu64u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntIndexu64u32::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu64u32::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu64u32,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu64u32::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu64u32::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu64u32,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntIndexu64u32::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu64u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu64u32::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntIndexu64u32> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu64u32::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntIndexu64u32::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntIndexu64u32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratoru64u64(IndexIterator<u64, u64>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratoru64u64 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratoru64u64 {
        const NAME: &'static str = "IndexIteratoru64u64";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratoru64u64 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratoru64u64 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratoru64u64 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratoru64u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratoru64u64 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratoru64u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratoru64u64 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratoru64u64 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratoru64u64>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratoru64u64 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIteratoru64u64,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratoru64u64> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru64u64 {}
    impl IndexIteratoru64u64 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru64u64 {}
    impl IndexIteratoru64u64 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(u64, u64)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((index_entry.key, index_entry.val.try_into().unwrap()))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratoru64u64>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratoru64u64> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratoru64u64::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratoru64u64::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru64u64 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru64u64::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratoru64u64::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru64u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru64u64::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratoru64u64::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru64u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntIndexu64u64(pub Index<u64, u64>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntIndexu64u64 {
        #[inline]
        fn clone(&self) -> IntIndexu64u64 {
            IntIndexu64u64(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntIndexu64u64 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntIndexu64u64 {
        const NAME: &'static str = "IntIndexu64u64";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntIndexu64u64 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntIndexu64u64 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntIndexu64u64 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntIndexu64u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntIndexu64u64 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntIndexu64u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntIndexu64u64 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntIndexu64u64 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntIndexu64u64>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntIndexu64u64 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntIndexu64u64>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntIndexu64u64> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu64u64 {}
    impl IntIndexu64u64 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu64u64 {}
    impl IntIndexu64u64 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u64, u64> {
                            key: i.getattr("key")?.extract::<u64>().unwrap(),
                            val: i.getattr("val")?.extract::<u64>().unwrap(),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u64,
                        u64,
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u64) -> PyResult<u64> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u64, u64>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratoru64u64>> {
            let iter = IndexIteratoru64u64(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntIndexu64u64>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntIndexu64u64> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntIndexu64u64::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntIndexu64u64::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntIndexu64u64::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntIndexu64u64>
                                for PyClassImplCollector<IntIndexu64u64> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntIndexu64u64::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntIndexu64u64::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu64u64 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu64u64::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu64u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntIndexu64u64::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu64u64::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu64u64,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu64u64::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu64u64::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu64u64,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntIndexu64u64::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu64u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu64u64::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntIndexu64u64> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu64u64::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntIndexu64u64::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntIndexu64u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratoru64u128(IndexIterator<u64, u128>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratoru64u128 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratoru64u128 {
        const NAME: &'static str = "IndexIteratoru64u128";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratoru64u128 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratoru64u128 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratoru64u128 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratoru64u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratoru64u128 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratoru64u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratoru64u128 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratoru64u128 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratoru64u128>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratoru64u128 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIteratoru64u128,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratoru64u128> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru64u128 {}
    impl IndexIteratoru64u128 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru64u128 {}
    impl IndexIteratoru64u128 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(u64, u128)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((index_entry.key, index_entry.val.try_into().unwrap()))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratoru64u128>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratoru64u128> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratoru64u128::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratoru64u128::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru64u128 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru64u128::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratoru64u128::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru64u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru64u128::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratoru64u128::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru64u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntIndexu64u128(pub Index<u64, u128>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntIndexu64u128 {
        #[inline]
        fn clone(&self) -> IntIndexu64u128 {
            IntIndexu64u128(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntIndexu64u128 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntIndexu64u128 {
        const NAME: &'static str = "IntIndexu64u128";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntIndexu64u128 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntIndexu64u128 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntIndexu64u128 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntIndexu64u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntIndexu64u128 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntIndexu64u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntIndexu64u128 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntIndexu64u128 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntIndexu64u128>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntIndexu64u128 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntIndexu64u128>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntIndexu64u128> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu64u128 {}
    impl IntIndexu64u128 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu64u128 {}
    impl IntIndexu64u128 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u64, u128> {
                            key: i.getattr("key")?.extract::<u64>().unwrap(),
                            val: i.getattr("val")?.extract::<u128>().unwrap(),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u64,
                        u128,
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u64) -> PyResult<u128> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u64, u128>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratoru64u128>> {
            let iter = IndexIteratoru64u128(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntIndexu64u128>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntIndexu64u128> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntIndexu64u128::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntIndexu64u128::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntIndexu64u128::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntIndexu64u128>
                                for PyClassImplCollector<IntIndexu64u128> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntIndexu64u128::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntIndexu64u128::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu64u128 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu64u128::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu64u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntIndexu64u128::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu64u128::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu64u128,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu64u128::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu64u128::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu64u128,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntIndexu64u128::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu64u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu64u128::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntIndexu64u128> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu64u128::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntIndexu64u128::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntIndexu64u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratorSetu64(pub IndexIterator<u64, ()>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratorSetu64 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratorSetu64 {
        const NAME: &'static str = "IndexIteratorSetu64";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratorSetu64 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratorSetu64 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratorSetu64 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratorSetu64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratorSetu64 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratorSetu64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratorSetu64 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratorSetu64 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratorSetu64>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratorSetu64 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIteratorSetu64,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratorSetu64> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratorSetu64 {}
    impl IndexIteratorSetu64 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratorSetu64 {}
    impl IndexIteratorSetu64 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<u64> {
            match slf.0.next() {
                Some(index_entry) => Some(index_entry.key),
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratorSetu64>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratorSetu64> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratorSetu64::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratorSetu64::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratorSetu64 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratorSetu64::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratorSetu64::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratorSetu64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratorSetu64::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratorSetu64::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratorSetu64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntSetu64(pub Index<u64, ()>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntSetu64 {
        #[inline]
        fn clone(&self) -> IntSetu64 {
            IntSetu64(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntSetu64 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntSetu64 {
        const NAME: &'static str = "IntSetu64";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntSetu64 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntSetu64 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntSetu64 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntSetu64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntSetu64 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntSetu64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntSetu64 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntSetu64 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntSetu64>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntSetu64 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntSetu64>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntSetu64> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntSetu64 {}
    impl IntSetu64 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntSetu64 {}
    impl IntSetu64 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u64, ()> {
                            key: i.getattr("key")?.extract::<u64>().unwrap(),
                            val: (),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u64,
                        (),
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u64) -> PyResult<()> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        pub fn __contains__(&self, key: u64) -> PyResult<bool> {
            match self.0.get(key) {
                Ok(_) => Ok(true),
                _ => Ok(false),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u64, ()>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratorSetu64>> {
            let iter = IndexIteratorSetu64(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntSetu64>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntSetu64> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntSetu64::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntSetu64::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntSetu64::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> ::std::os::raw::c_int {
                            ::pyo3::impl_::trampoline::objobjproc(
                                _slf,
                                arg0,
                                IntSetu64::__pymethod___contains____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_sq_contains,
                            pfunc: trampoline as ::pyo3::ffi::objobjproc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntSetu64>
                                for PyClassImplCollector<IntSetu64> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntSetu64::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntSetu64::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntSetu64 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntSetu64::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntSetu64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntSetu64::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntSetu64::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntSetu64,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntSetu64::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntSetu64::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntSetu64,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___contains____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::std::os::raw::c_int> {
            let function = IntSetu64::__contains__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntSetu64::__contains__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntSetu64,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntSetu64::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntSetu64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntSetu64::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntSetu64> = result.convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntSetu64::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntSetu64::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntSetu64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratoru128u8(IndexIterator<u128, u8>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratoru128u8 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratoru128u8 {
        const NAME: &'static str = "IndexIteratoru128u8";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratoru128u8 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratoru128u8 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratoru128u8 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratoru128u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratoru128u8 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratoru128u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratoru128u8 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratoru128u8 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratoru128u8>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratoru128u8 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIteratoru128u8,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratoru128u8> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru128u8 {}
    impl IndexIteratoru128u8 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru128u8 {}
    impl IndexIteratoru128u8 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(u128, u8)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((index_entry.key, index_entry.val.try_into().unwrap()))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratoru128u8>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratoru128u8> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratoru128u8::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratoru128u8::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru128u8 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru128u8::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratoru128u8::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru128u8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru128u8::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratoru128u8::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru128u8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntIndexu128u8(pub Index<u128, u8>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntIndexu128u8 {
        #[inline]
        fn clone(&self) -> IntIndexu128u8 {
            IntIndexu128u8(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntIndexu128u8 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntIndexu128u8 {
        const NAME: &'static str = "IntIndexu128u8";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntIndexu128u8 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntIndexu128u8 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntIndexu128u8 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntIndexu128u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntIndexu128u8 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntIndexu128u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntIndexu128u8 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntIndexu128u8 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntIndexu128u8>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntIndexu128u8 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntIndexu128u8>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntIndexu128u8> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu128u8 {}
    impl IntIndexu128u8 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu128u8 {}
    impl IntIndexu128u8 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u128, u8> {
                            key: i.getattr("key")?.extract::<u128>().unwrap(),
                            val: i.getattr("val")?.extract::<u8>().unwrap(),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u128,
                        u8,
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u128) -> PyResult<u8> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u128, u8>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratoru128u8>> {
            let iter = IndexIteratoru128u8(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntIndexu128u8>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntIndexu128u8> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntIndexu128u8::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntIndexu128u8::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntIndexu128u8::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntIndexu128u8>
                                for PyClassImplCollector<IntIndexu128u8> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntIndexu128u8::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntIndexu128u8::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu128u8 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu128u8::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu128u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntIndexu128u8::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu128u8::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu128u8,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu128u8::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu128u8::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu128u8,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntIndexu128u8::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu128u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu128u8::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntIndexu128u8> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu128u8::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntIndexu128u8::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntIndexu128u8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratoru128u16(IndexIterator<u128, u16>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratoru128u16 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratoru128u16 {
        const NAME: &'static str = "IndexIteratoru128u16";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratoru128u16 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratoru128u16 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratoru128u16 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratoru128u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratoru128u16 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratoru128u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratoru128u16 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratoru128u16 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratoru128u16>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratoru128u16 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIteratoru128u16,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratoru128u16> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru128u16 {}
    impl IndexIteratoru128u16 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru128u16 {}
    impl IndexIteratoru128u16 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(u128, u16)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((index_entry.key, index_entry.val.try_into().unwrap()))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratoru128u16>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratoru128u16> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratoru128u16::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratoru128u16::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru128u16 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru128u16::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratoru128u16::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru128u16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru128u16::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratoru128u16::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru128u16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntIndexu128u16(pub Index<u128, u16>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntIndexu128u16 {
        #[inline]
        fn clone(&self) -> IntIndexu128u16 {
            IntIndexu128u16(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntIndexu128u16 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntIndexu128u16 {
        const NAME: &'static str = "IntIndexu128u16";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntIndexu128u16 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntIndexu128u16 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntIndexu128u16 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntIndexu128u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntIndexu128u16 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntIndexu128u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntIndexu128u16 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntIndexu128u16 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntIndexu128u16>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntIndexu128u16 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntIndexu128u16>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntIndexu128u16> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu128u16 {}
    impl IntIndexu128u16 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu128u16 {}
    impl IntIndexu128u16 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u128, u16> {
                            key: i.getattr("key")?.extract::<u128>().unwrap(),
                            val: i.getattr("val")?.extract::<u16>().unwrap(),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u128,
                        u16,
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u128) -> PyResult<u16> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u128, u16>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratoru128u16>> {
            let iter = IndexIteratoru128u16(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntIndexu128u16>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntIndexu128u16> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntIndexu128u16::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntIndexu128u16::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntIndexu128u16::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntIndexu128u16>
                                for PyClassImplCollector<IntIndexu128u16> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntIndexu128u16::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntIndexu128u16::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu128u16 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu128u16::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu128u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntIndexu128u16::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu128u16::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu128u16,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu128u16::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu128u16::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu128u16,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntIndexu128u16::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu128u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu128u16::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntIndexu128u16> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu128u16::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntIndexu128u16::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntIndexu128u16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratoru128u32(IndexIterator<u128, u32>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratoru128u32 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratoru128u32 {
        const NAME: &'static str = "IndexIteratoru128u32";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratoru128u32 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratoru128u32 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratoru128u32 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratoru128u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratoru128u32 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratoru128u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratoru128u32 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratoru128u32 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratoru128u32>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratoru128u32 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIteratoru128u32,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratoru128u32> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru128u32 {}
    impl IndexIteratoru128u32 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru128u32 {}
    impl IndexIteratoru128u32 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(u128, u32)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((index_entry.key, index_entry.val.try_into().unwrap()))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratoru128u32>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratoru128u32> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratoru128u32::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratoru128u32::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru128u32 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru128u32::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratoru128u32::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru128u32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru128u32::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratoru128u32::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru128u32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntIndexu128u32(pub Index<u128, u32>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntIndexu128u32 {
        #[inline]
        fn clone(&self) -> IntIndexu128u32 {
            IntIndexu128u32(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntIndexu128u32 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntIndexu128u32 {
        const NAME: &'static str = "IntIndexu128u32";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntIndexu128u32 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntIndexu128u32 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntIndexu128u32 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntIndexu128u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntIndexu128u32 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntIndexu128u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntIndexu128u32 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntIndexu128u32 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntIndexu128u32>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntIndexu128u32 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntIndexu128u32>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntIndexu128u32> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu128u32 {}
    impl IntIndexu128u32 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu128u32 {}
    impl IntIndexu128u32 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u128, u32> {
                            key: i.getattr("key")?.extract::<u128>().unwrap(),
                            val: i.getattr("val")?.extract::<u32>().unwrap(),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u128,
                        u32,
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u128) -> PyResult<u32> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u128, u32>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratoru128u32>> {
            let iter = IndexIteratoru128u32(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntIndexu128u32>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntIndexu128u32> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntIndexu128u32::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntIndexu128u32::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntIndexu128u32::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntIndexu128u32>
                                for PyClassImplCollector<IntIndexu128u32> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntIndexu128u32::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntIndexu128u32::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu128u32 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu128u32::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu128u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntIndexu128u32::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu128u32::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu128u32,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu128u32::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu128u32::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu128u32,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntIndexu128u32::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu128u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu128u32::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntIndexu128u32> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu128u32::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntIndexu128u32::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntIndexu128u32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratoru128u64(IndexIterator<u128, u64>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratoru128u64 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratoru128u64 {
        const NAME: &'static str = "IndexIteratoru128u64";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratoru128u64 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratoru128u64 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratoru128u64 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratoru128u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratoru128u64 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratoru128u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratoru128u64 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratoru128u64 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratoru128u64>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratoru128u64 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIteratoru128u64,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratoru128u64> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru128u64 {}
    impl IndexIteratoru128u64 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru128u64 {}
    impl IndexIteratoru128u64 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(u128, u64)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((index_entry.key, index_entry.val.try_into().unwrap()))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratoru128u64>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratoru128u64> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratoru128u64::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratoru128u64::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru128u64 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru128u64::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratoru128u64::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru128u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru128u64::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratoru128u64::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru128u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntIndexu128u64(pub Index<u128, u64>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntIndexu128u64 {
        #[inline]
        fn clone(&self) -> IntIndexu128u64 {
            IntIndexu128u64(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntIndexu128u64 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntIndexu128u64 {
        const NAME: &'static str = "IntIndexu128u64";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntIndexu128u64 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntIndexu128u64 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntIndexu128u64 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntIndexu128u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntIndexu128u64 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntIndexu128u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntIndexu128u64 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntIndexu128u64 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntIndexu128u64>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntIndexu128u64 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntIndexu128u64>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntIndexu128u64> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu128u64 {}
    impl IntIndexu128u64 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu128u64 {}
    impl IntIndexu128u64 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u128, u64> {
                            key: i.getattr("key")?.extract::<u128>().unwrap(),
                            val: i.getattr("val")?.extract::<u64>().unwrap(),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u128,
                        u64,
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u128) -> PyResult<u64> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u128, u64>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratoru128u64>> {
            let iter = IndexIteratoru128u64(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntIndexu128u64>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntIndexu128u64> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntIndexu128u64::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntIndexu128u64::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntIndexu128u64::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntIndexu128u64>
                                for PyClassImplCollector<IntIndexu128u64> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntIndexu128u64::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntIndexu128u64::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu128u64 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu128u64::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu128u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntIndexu128u64::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu128u64::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu128u64,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu128u64::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu128u64::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu128u64,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntIndexu128u64::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu128u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu128u64::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntIndexu128u64> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu128u64::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntIndexu128u64::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntIndexu128u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratoru128u128(IndexIterator<u128, u128>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratoru128u128 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratoru128u128 {
        const NAME: &'static str = "IndexIteratoru128u128";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratoru128u128 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratoru128u128 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratoru128u128 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratoru128u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratoru128u128 {
        type Holder = ::std::option::Option<
            ::pyo3::PyRefMut<'py, IndexIteratoru128u128>,
        >;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratoru128u128 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratoru128u128 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratoru128u128>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratoru128u128 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIteratoru128u128,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratoru128u128> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru128u128 {}
    impl IndexIteratoru128u128 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru128u128 {}
    impl IndexIteratoru128u128 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(u128, u128)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((index_entry.key, index_entry.val.try_into().unwrap()))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratoru128u128>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratoru128u128> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratoru128u128::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratoru128u128::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratoru128u128 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru128u128::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratoru128u128::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru128u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratoru128u128::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratoru128u128::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratoru128u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntIndexu128u128(pub Index<u128, u128>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntIndexu128u128 {
        #[inline]
        fn clone(&self) -> IntIndexu128u128 {
            IntIndexu128u128(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntIndexu128u128 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntIndexu128u128 {
        const NAME: &'static str = "IntIndexu128u128";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntIndexu128u128 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntIndexu128u128 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntIndexu128u128 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntIndexu128u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntIndexu128u128 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntIndexu128u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntIndexu128u128 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntIndexu128u128 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntIndexu128u128>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntIndexu128u128 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntIndexu128u128>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntIndexu128u128> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu128u128 {}
    impl IntIndexu128u128 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu128u128 {}
    impl IntIndexu128u128 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u128, u128> {
                            key: i.getattr("key")?.extract::<u128>().unwrap(),
                            val: i.getattr("val")?.extract::<u128>().unwrap(),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u128,
                        u128,
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u128) -> PyResult<u128> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u128, u128>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratoru128u128>> {
            let iter = IndexIteratoru128u128(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntIndexu128u128>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntIndexu128u128> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntIndexu128u128::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntIndexu128u128::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntIndexu128u128::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntIndexu128u128>
                                for PyClassImplCollector<IntIndexu128u128> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntIndexu128u128::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntIndexu128u128::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntIndexu128u128 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu128u128::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu128u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntIndexu128u128::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu128u128::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu128u128,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu128u128::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu128u128::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntIndexu128u128,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntIndexu128u128::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntIndexu128u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntIndexu128u128::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntIndexu128u128> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntIndexu128u128::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntIndexu128u128::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntIndexu128u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct IndexIteratorSetu128(pub IndexIterator<u128, ()>);
    impl ::pyo3::types::DerefToPyAny for IndexIteratorSetu128 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIteratorSetu128 {
        const NAME: &'static str = "IndexIteratorSetu128";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIteratorSetu128 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIteratorSetu128 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIteratorSetu128 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIteratorSetu128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIteratorSetu128 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIteratorSetu128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIteratorSetu128 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIteratorSetu128 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIteratorSetu128>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIteratorSetu128 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIteratorSetu128,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIteratorSetu128> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratorSetu128 {}
    impl IndexIteratorSetu128 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratorSetu128 {}
    impl IndexIteratorSetu128 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<u128> {
            match slf.0.next() {
                Some(index_entry) => Some(index_entry.key),
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIteratorSetu128>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIteratorSetu128> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIteratorSetu128::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIteratorSetu128::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIteratorSetu128 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratorSetu128::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIteratorSetu128::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratorSetu128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIteratorSetu128::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIteratorSetu128::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIteratorSetu128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IntSetu128(pub Index<u128, ()>);
    #[automatically_derived]
    impl ::core::clone::Clone for IntSetu128 {
        #[inline]
        fn clone(&self) -> IntSetu128 {
            IntSetu128(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for IntSetu128 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IntSetu128 {
        const NAME: &'static str = "IntSetu128";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IntSetu128 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IntSetu128 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IntSetu128 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IntSetu128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IntSetu128 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IntSetu128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IntSetu128 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IntSetu128 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IntSetu128>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IntSetu128 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IntSetu128>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IntSetu128> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntSetu128 {}
    impl IntSetu128 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntSetu128 {}
    impl IntSetu128 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i.and_then(|i| {
                        Ok(IndexEntry::<u128, ()> {
                            key: i.getattr("key")?.extract::<u128>().unwrap(),
                            val: (),
                        })
                    })
                });
            Ok(
                Self(
                    Index::<
                        u128,
                        (),
                    >::build_index(entry_iter.map(|e| e.unwrap()), path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, key: u128) -> PyResult<()> {
            match self.0.get(key) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(key)),
            }
        }
        pub fn __contains__(&self, key: u128) -> PyResult<bool> {
            match self.0.get(key) {
                Ok(_) => Ok(true),
                _ => Ok(false),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(Index::<u128, ()>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIteratorSetu128>> {
            let iter = IndexIteratorSetu128(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IntSetu128>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IntSetu128> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                IntSetu128::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                IntSetu128::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                IntSetu128::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> ::std::os::raw::c_int {
                            ::pyo3::impl_::trampoline::objobjproc(
                                _slf,
                                arg0,
                                IntSetu128::__pymethod___contains____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_sq_contains,
                            pfunc: trampoline as ::pyo3::ffi::objobjproc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<IntSetu128>
                                for PyClassImplCollector<IntSetu128> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    IntSetu128::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IntSetu128::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IntSetu128 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntSetu128::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntSetu128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = IntSetu128::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntSetu128::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntSetu128,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntSetu128::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntSetu128::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntSetu128,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___contains____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::std::os::raw::c_int> {
            let function = IntSetu128::__contains__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntSetu128::__contains__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    IntSetu128,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "key",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = IntSetu128::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <IntSetu128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = IntSetu128::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<IntSetu128> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IntSetu128::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IntSetu128::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IntSetu128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
}
pub mod pykmer {
    use pyo3::exceptions::PyTypeError;
    use pyo3::prelude::*;
    use vizitig_lib::kmer::{DataStore, Kmer};
    pub struct PyKmer<const N: usize, T: DataStore<N> + Ord>(pub Kmer<N, T>);
    #[automatically_derived]
    impl<
        const N: usize,
        T: ::core::clone::Clone + DataStore<N> + Ord,
    > ::core::clone::Clone for PyKmer<N, T> {
        #[inline]
        fn clone(&self) -> PyKmer<N, T> {
            PyKmer(::core::clone::Clone::clone(&self.0))
        }
    }
    #[automatically_derived]
    impl<
        const N: usize,
        T: ::core::marker::Copy + DataStore<N> + Ord,
    > ::core::marker::Copy for PyKmer<N, T> {}
    impl<const N: usize, T: DataStore<N> + Ord> From<Kmer<N, T>> for PyKmer<N, T> {
        fn from(value: Kmer<N, T>) -> Self {
            Self(value)
        }
    }
    impl<const N: usize, T: DataStore<N> + Ord> From<PyKmer<N, T>> for Kmer<N, T> {
        fn from(value: PyKmer<N, T>) -> Self {
            value.0
        }
    }
    impl<'py, const N: usize, T> FromPyObject<'py> for PyKmer<N, T>
    where
        T: DataStore<N> + Ord + FromPyObject<'py>,
    {
        #[inline(always)]
        fn extract_bound(input: &Bound<'py, PyAny>) -> PyResult<Self> {
            let data: T = input.extract()?;
            Ok(Self(Kmer::<N, T>(data)))
        }
    }
    impl<'py, const N: usize, T> IntoPyObject<'py> for PyKmer<N, T>
    where
        T: DataStore<N> + Ord + IntoPyObject<'py, Output = Bound<'py, PyAny>>,
    {
        type Target = PyAny;
        type Output = Bound<'py, Self::Target>;
        type Error = PyErr;
        #[inline(always)]
        fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
            match self.0.0.into_pyobject(py) {
                Ok(val) => Ok(val),
                Err(_) => Err(PyTypeError::new_err("Conversion error")),
            }
        }
    }
    pub(crate) use kmer;
}
pub mod pykmer_index {
    pub(crate) use PyIndexIterator;
    pub(crate) use PyKmerIndex;
    pub(crate) use PyKmerSet;
}
#[cfg(feature = "few_kmer")]
fn base_kmer(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
    pub struct PyKmer21(pub PyKmer<21, u64>);
    #[automatically_derived]
    impl ::core::clone::Clone for PyKmer21 {
        #[inline]
        fn clone(&self) -> PyKmer21 {
            PyKmer21(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for PyKmer21 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for PyKmer21 {
        const NAME: &'static str = "PyKmer21";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <PyKmer21 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for PyKmer21 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a PyKmer21 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, PyKmer21>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut PyKmer21 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, PyKmer21>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for PyKmer21 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for PyKmer21 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<PyKmer21>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for PyKmer21 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<PyKmer21>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<PyKmer21> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl PyKmer21 {}
    impl PyKmer21 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl PyKmer21 {}
    impl PyKmer21 {
        pub fn new(data: u64) -> PyResult<Self> {
            Ok(Self(PyKmer::<21, u64>(Kmer::<21, u64>(data.into()))))
        }
        pub fn enumerate_canonical_kmer(
            _: &Bound<'_, PyType>,
            dna: PyDNA,
        ) -> PyResult<Vec<Self>> {
            let it: CanonicalKmerIterator<21, u64> = (&(dna.0)).try_into().unwrap();
            Ok(it.map(|u| Self(u.into())).collect())
        }
        pub fn count__kmer(_: &Bound<'_, PyType>, dna: PyDNA) -> PyResult<usize> {
            let it: KmerIterator<21, u64> = (&(dna.0)).try_into().unwrap();
            Ok(it.count())
        }
        pub fn enumerate_kmer(_: &Bound<'_, PyType>, dna: PyDNA) -> PyResult<Vec<Self>> {
            let it: KmerIterator<21, u64> = (&(dna.0)).try_into().unwrap();
            Ok(it.map(|u| Self(u.into())).collect())
        }
        pub fn size() -> PyResult<usize> {
            Ok(21)
        }
        pub fn add_left_nucleotid(&self, n: PyNucleotid) -> PyResult<Self> {
            Ok(Self(self.0.0.append_left(n.0).into()))
        }
        pub fn add_right_nucleotid(&self, n: PyNucleotid) -> PyResult<Self> {
            Ok(Self(self.0.0.append(n.0).into()))
        }
        pub fn reverse_complement(&self) -> PyResult<Self> {
            Ok(Self(self.0.0.rc().into()))
        }
        pub fn canonical(&self) -> PyResult<Self> {
            Ok(Self(self.0.0.normalize().into()))
        }
        pub fn is_canonical(&self) -> PyResult<bool> {
            Ok(self.0.0 == self.0.0.normalize())
        }
        pub fn data(&self) -> PyResult<u64> {
            Ok(self.0.0.get_data().into())
        }
        pub fn __hash__(&self) -> PyResult<u64> {
            Ok(self.0.0.hash())
        }
        pub fn __repr__(&self) -> PyResult<String> {
            Ok(
                ::alloc::__export::must_use({
                    let res = ::alloc::fmt::format(format_args!("{0}", &self.0.0));
                    res
                }),
            )
        }
        pub fn __str__(&self) -> PyResult<String> {
            Ok((&self.0.0).into())
        }
        pub fn __lt__(&self, other: Self) -> PyResult<bool> {
            Ok(self.0.0 <= other.0.0)
        }
        pub fn __gt__(&self, other: Self) -> PyResult<bool> {
            Ok(self.0.0 >= other.0.0)
        }
        pub fn __eq__(&self, other: Self) -> PyResult<bool> {
            Ok(self.0.0 == other.0.0)
        }
    }
    impl PyKmer21 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___lt____(
            py: ::pyo3::Python,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyKmer21::__lt__(
                match ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    PyKmer21,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                ) {
                    ::std::result::Result::Ok(value) => value,
                    ::std::result::Result::Err(_) => {
                        return ::pyo3::impl_::callback::convert(py, py.NotImplemented());
                    }
                },
                match ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "other",
                ) {
                    ::std::result::Result::Ok(value) => value,
                    ::std::result::Result::Err(_) => {
                        return ::pyo3::impl_::callback::convert(py, py.NotImplemented());
                    }
                },
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    impl ::pyo3::impl_::pyclass::PyClass__lt__SlotFragment<PyKmer21>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<PyKmer21> {
        #[inline]
        unsafe fn __lt__(
            self,
            py: ::pyo3::Python,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            PyKmer21::__pymethod___lt____(py, _raw_slf, arg0)
        }
    }
    impl PyKmer21 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___gt____(
            py: ::pyo3::Python,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyKmer21::__gt__(
                match ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    PyKmer21,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                ) {
                    ::std::result::Result::Ok(value) => value,
                    ::std::result::Result::Err(_) => {
                        return ::pyo3::impl_::callback::convert(py, py.NotImplemented());
                    }
                },
                match ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "other",
                ) {
                    ::std::result::Result::Ok(value) => value,
                    ::std::result::Result::Err(_) => {
                        return ::pyo3::impl_::callback::convert(py, py.NotImplemented());
                    }
                },
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    impl ::pyo3::impl_::pyclass::PyClass__gt__SlotFragment<PyKmer21>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<PyKmer21> {
        #[inline]
        unsafe fn __gt__(
            self,
            py: ::pyo3::Python,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            PyKmer21::__pymethod___gt____(py, _raw_slf, arg0)
        }
    }
    impl PyKmer21 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___eq____(
            py: ::pyo3::Python,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyKmer21::__eq__(
                match ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    PyKmer21,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                ) {
                    ::std::result::Result::Ok(value) => value,
                    ::std::result::Result::Err(_) => {
                        return ::pyo3::impl_::callback::convert(py, py.NotImplemented());
                    }
                },
                match ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "other",
                ) {
                    ::std::result::Result::Ok(value) => value,
                    ::std::result::Result::Err(_) => {
                        return ::pyo3::impl_::callback::convert(py, py.NotImplemented());
                    }
                },
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    impl ::pyo3::impl_::pyclass::PyClass__eq__SlotFragment<PyKmer21>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<PyKmer21> {
        #[inline]
        unsafe fn __eq__(
            self,
            py: ::pyo3::Python,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            PyKmer21::__pymethod___eq____(py, _raw_slf, arg0)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<PyKmer21>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<PyKmer21> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"enumerate_canonical_kmer",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                PyKmer21::__pymethod_enumerate_canonical_kmer__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"enumerate_canonical_kmer($cls, dna)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"count__kmer",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                PyKmer21::__pymethod_count__kmer__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"count__kmer($cls, dna)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"enumerate_kmer",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                PyKmer21::__pymethod_enumerate_kmer__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"enumerate_kmer($cls, dna)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Static(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                    c"size",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            unsafe {
                                                ::pyo3::impl_::trampoline::noargs(
                                                    _slf,
                                                    _args,
                                                    PyKmer21::__pymethod_size__,
                                                )
                                            }
                                        }
                                        trampoline
                                    },
                                    c"size()\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_STATIC),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"add_left_nucleotid",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            PyKmer21::__pymethod_add_left_nucleotid__,
                                        )
                                    }
                                    trampoline
                                },
                                c"add_left_nucleotid($self, n)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"add_right_nucleotid",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            PyKmer21::__pymethod_add_right_nucleotid__,
                                        )
                                    }
                                    trampoline
                                },
                                c"add_right_nucleotid($self, n)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                c"reverse_complement",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        unsafe {
                                            ::pyo3::impl_::trampoline::noargs(
                                                _slf,
                                                _args,
                                                PyKmer21::__pymethod_reverse_complement__,
                                            )
                                        }
                                    }
                                    trampoline
                                },
                                c"reverse_complement($self)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                c"canonical",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        unsafe {
                                            ::pyo3::impl_::trampoline::noargs(
                                                _slf,
                                                _args,
                                                PyKmer21::__pymethod_canonical__,
                                            )
                                        }
                                    }
                                    trampoline
                                },
                                c"canonical($self)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                c"is_canonical",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        unsafe {
                                            ::pyo3::impl_::trampoline::noargs(
                                                _slf,
                                                _args,
                                                PyKmer21::__pymethod_is_canonical__,
                                            )
                                        }
                                    }
                                    trampoline
                                },
                                c"is_canonical($self)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Getter(
                            ::pyo3::impl_::pymethods::PyGetterDef::new(
                                c"data",
                                PyKmer21::__pymethod_get_data__,
                                c"",
                            ),
                        ),
                    ),
                ],
                slots: &[
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<PyKmer21>
                                for PyClassImplCollector<PyKmer21> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(data)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    PyKmer21::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_hash_t {
                            ::pyo3::impl_::trampoline::hashfunc(
                                _slf,
                                PyKmer21::__pymethod___hash____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_hash,
                            pfunc: trampoline as ::pyo3::ffi::hashfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::reprfunc(
                                _slf,
                                PyKmer21::__pymethod___repr____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_repr,
                            pfunc: trampoline as ::pyo3::ffi::reprfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::reprfunc(
                                _slf,
                                PyKmer21::__pymethod___str____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_str,
                            pfunc: trampoline as ::pyo3::ffi::reprfunc as _,
                        }
                    },
                    {
                        #[allow(unknown_lints, non_local_definitions)]
                        impl PyKmer21 {
                            #[allow(non_snake_case)]
                            unsafe extern "C" fn __pymethod___richcmp____(
                                slf: *mut ::pyo3::ffi::PyObject,
                                other: *mut ::pyo3::ffi::PyObject,
                                op: ::std::os::raw::c_int,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                impl ::pyo3::impl_::pyclass::HasCustomRichCmp for PyKmer21 {}
                                ::pyo3::impl_::trampoline::richcmpfunc(
                                    slf,
                                    other,
                                    op,
                                    |py, slf, other, op| {
                                        use ::pyo3::class::basic::CompareOp;
                                        use ::pyo3::impl_::pyclass::*;
                                        let collector = PyClassImplCollector::<PyKmer21>::new();
                                        match CompareOp::from_raw(op).expect("invalid compareop") {
                                            CompareOp::Lt => collector.__lt__(py, slf, other),
                                            CompareOp::Le => collector.__le__(py, slf, other),
                                            CompareOp::Eq => collector.__eq__(py, slf, other),
                                            CompareOp::Ne => collector.__ne__(py, slf, other),
                                            CompareOp::Gt => collector.__gt__(py, slf, other),
                                            CompareOp::Ge => collector.__ge__(py, slf, other),
                                        }
                                    },
                                )
                            }
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_richcompare,
                            pfunc: <PyKmer21>::__pymethod___richcmp____
                                as ::pyo3::ffi::richcmpfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl PyKmer21 {
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = PyKmer21::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyKmer21 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["data"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyKmer21::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "data",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<PyKmer21> = result.convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        unsafe fn __pymethod_enumerate_canonical_kmer__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer21::enumerate_canonical_kmer;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyKmer21 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "enumerate_canonical_kmer",
                positional_parameter_names: &["dna"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "dna",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_count__kmer__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer21::count__kmer;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyKmer21 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "count__kmer",
                positional_parameter_names: &["dna"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "dna",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_enumerate_kmer__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer21::enumerate_kmer;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyKmer21 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "enumerate_kmer",
                positional_parameter_names: &["dna"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "dna",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_size__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer21::size;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function();
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_add_left_nucleotid__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer21::add_left_nucleotid;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyKmer21 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "add_left_nucleotid",
                positional_parameter_names: &["n"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyKmer21,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "n",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_add_right_nucleotid__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer21::add_right_nucleotid;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyKmer21 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "add_right_nucleotid",
                positional_parameter_names: &["n"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyKmer21,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "n",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_reverse_complement__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer21::reverse_complement;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyKmer21,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_0,
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_canonical__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer21::canonical;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyKmer21,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_0,
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_is_canonical__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer21::is_canonical;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyKmer21,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_0,
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_get_data__(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = ::pyo3::impl_::callback::convert(
                py,
                PyKmer21::data(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyKmer21,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_0,
                    )?,
                ),
            );
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___hash____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_hash_t> {
            let function = PyKmer21::__hash__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let _result: ::pyo3::PyResult<::pyo3::impl_::callback::HashCallbackOutput> = ::pyo3::impl_::callback::convert(
                py,
                PyKmer21::__hash__(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyKmer21,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_0,
                    )?,
                ),
            );
            ::pyo3::impl_::callback::convert(py, _result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___repr____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer21::__repr__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyKmer21::__repr__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    PyKmer21,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___str____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer21::__str__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyKmer21::__str__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    PyKmer21,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct KmerSet21(KmerIndex<21, u64, ()>);
    #[automatically_derived]
    impl ::core::clone::Clone for KmerSet21 {
        #[inline]
        fn clone(&self) -> KmerSet21 {
            KmerSet21(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for KmerSet21 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for KmerSet21 {
        const NAME: &'static str = "KmerSet21";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <KmerSet21 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for KmerSet21 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a KmerSet21 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, KmerSet21>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut KmerSet21 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, KmerSet21>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for KmerSet21 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for KmerSet21 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<KmerSet21>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for KmerSet21 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<KmerSet21>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<KmerSet21> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerSet21 {}
    impl KmerSet21 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerSet21 {}
    impl KmerSet21 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let kmer_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let kmer = base_tuple
                                .get_item(0)?
                                .extract::<PyKmer21>()
                                .unwrap()
                                .0;
                            Ok(KmerIndexEntry::<21, u64, ()> {
                                key: kmer.into(),
                                val: (),
                            })
                        })
                });
            Ok(
                Self(
                    KmerIndex::<
                        21,
                        u64,
                        (),
                    >::build_index(
                            kmer_entry_iter.map(|e| e.unwrap()),
                            path,
                            buffer_size,
                        )
                        .unwrap(),
                ),
            )
        }
        pub fn build_dna(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
            index: u64,
            modulo: u64,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let dna_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let dna = i.extract::<PyDNA>().unwrap().0;
                            Ok(dna)
                        })
                });
            let kmer_iter = dna_entry_iter
                .map(|e| e.unwrap())
                .flat_map(|dna| {
                    let kmer_it: CanonicalKmerIterator<21, u64> = (&dna).into();
                    let kmer_it_filt = kmer_it
                        .filter(|kmer| kmer.hash() % modulo == index)
                        .map(move |kmer| KmerIndexEntry::<21, u64, ()> {
                            key: kmer,
                            val: (),
                        });
                    let kmer_vec: Vec<KmerIndexEntry<21, u64, ()>> = kmer_it_filt
                        .collect();
                    kmer_vec.into_iter()
                });
            Ok(
                Self(
                    KmerIndex::<21, u64, ()>::build_index(kmer_iter, path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __contains__(&self, kmer: PyKmer21) -> PyResult<bool> {
            match self.0.get(kmer.0.into()) {
                Ok(_) => Ok(true),
                _ => Ok(false),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(KmerIndex::<21, u64, ()>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexSetIterator21u64>> {
            let iter = IndexSetIterator21u64(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
        fn size() -> PyResult<usize> {
            Ok(21)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<KmerSet21>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<KmerSet21> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerSet21::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build_dna",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerSet21::__pymethod_build_dna__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build_dna($cls, iterator, index_path, buffer_size, index, modulo)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Static(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                    c"size",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            unsafe {
                                                ::pyo3::impl_::trampoline::noargs(
                                                    _slf,
                                                    _args,
                                                    KmerSet21::__pymethod_size__,
                                                )
                                            }
                                        }
                                        trampoline
                                    },
                                    c"size()\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_STATIC),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                KmerSet21::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> ::std::os::raw::c_int {
                            ::pyo3::impl_::trampoline::objobjproc(
                                _slf,
                                arg0,
                                KmerSet21::__pymethod___contains____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_sq_contains,
                            pfunc: trampoline as ::pyo3::ffi::objobjproc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<KmerSet21>
                                for PyClassImplCollector<KmerSet21> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    KmerSet21::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                KmerSet21::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerSet21 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerSet21::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerSet21 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_build_dna__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerSet21::build_dna;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerSet21 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build_dna",
                positional_parameter_names: &[
                    "iterator",
                    "index_path",
                    "buffer_size",
                    "index",
                    "modulo",
                ],
                positional_only_parameters: 0usize,
                required_positional_parameters: 5usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 5usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_4 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[3usize].as_deref(),
                            )
                        },
                        &mut holder_3,
                        "index",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[4usize].as_deref(),
                            )
                        },
                        &mut holder_4,
                        "modulo",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = KmerSet21::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerSet21::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerSet21,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___contains____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::std::os::raw::c_int> {
            let function = KmerSet21::__contains__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerSet21::__contains__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerSet21,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "kmer",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = KmerSet21::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerSet21 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerSet21::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<KmerSet21> = result.convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerSet21::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = KmerSet21::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<KmerSet21>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod_size__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerSet21::size;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function();
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
    }
    pub struct IndexSetIterator21u64(IndexIterator<Kmer<21, u64>, ()>);
    impl ::pyo3::types::DerefToPyAny for IndexSetIterator21u64 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexSetIterator21u64 {
        const NAME: &'static str = "IndexSetIterator21u64";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexSetIterator21u64 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexSetIterator21u64 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexSetIterator21u64 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexSetIterator21u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexSetIterator21u64 {
        type Holder = ::std::option::Option<
            ::pyo3::PyRefMut<'py, IndexSetIterator21u64>,
        >;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexSetIterator21u64 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexSetIterator21u64 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexSetIterator21u64>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexSetIterator21u64 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexSetIterator21u64,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexSetIterator21u64> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexSetIterator21u64 {}
    impl IndexSetIterator21u64 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexSetIterator21u64 {}
    impl IndexSetIterator21u64 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<PyKmer21> {
            match slf.0.next() {
                Some(index_entry) => Some(PyKmer21(index_entry.key.into())),
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexSetIterator21u64>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexSetIterator21u64> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexSetIterator21u64::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexSetIterator21u64::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexSetIterator21u64 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexSetIterator21u64::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexSetIterator21u64::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexSetIterator21u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexSetIterator21u64::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexSetIterator21u64::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexSetIterator21u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IndexIterator21u8(IndexIterator<Kmer<21, u64>, u8>);
    impl ::pyo3::types::DerefToPyAny for IndexIterator21u8 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIterator21u8 {
        const NAME: &'static str = "IndexIterator21u8";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIterator21u8 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIterator21u8 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIterator21u8 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIterator21u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIterator21u8 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIterator21u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIterator21u8 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIterator21u8 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIterator21u8>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIterator21u8 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IndexIterator21u8>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIterator21u8> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator21u8 {}
    impl IndexIterator21u8 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator21u8 {}
    impl IndexIterator21u8 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(PyKmer21, u8)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((PyKmer21(index_entry.key.into()), index_entry.val))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIterator21u8>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIterator21u8> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIterator21u8::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIterator21u8::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator21u8 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator21u8::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIterator21u8::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator21u8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator21u8::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIterator21u8::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator21u8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IndexIterator21u16(IndexIterator<Kmer<21, u64>, u16>);
    impl ::pyo3::types::DerefToPyAny for IndexIterator21u16 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIterator21u16 {
        const NAME: &'static str = "IndexIterator21u16";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIterator21u16 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIterator21u16 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIterator21u16 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIterator21u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIterator21u16 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIterator21u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIterator21u16 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIterator21u16 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIterator21u16>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIterator21u16 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IndexIterator21u16>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIterator21u16> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator21u16 {}
    impl IndexIterator21u16 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator21u16 {}
    impl IndexIterator21u16 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(PyKmer21, u16)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((PyKmer21(index_entry.key.into()), index_entry.val))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIterator21u16>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIterator21u16> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIterator21u16::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIterator21u16::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator21u16 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator21u16::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIterator21u16::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator21u16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator21u16::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIterator21u16::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator21u16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IndexIterator21u32(IndexIterator<Kmer<21, u64>, u32>);
    impl ::pyo3::types::DerefToPyAny for IndexIterator21u32 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIterator21u32 {
        const NAME: &'static str = "IndexIterator21u32";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIterator21u32 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIterator21u32 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIterator21u32 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIterator21u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIterator21u32 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIterator21u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIterator21u32 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIterator21u32 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIterator21u32>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIterator21u32 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IndexIterator21u32>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIterator21u32> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator21u32 {}
    impl IndexIterator21u32 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator21u32 {}
    impl IndexIterator21u32 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(PyKmer21, u32)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((PyKmer21(index_entry.key.into()), index_entry.val))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIterator21u32>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIterator21u32> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIterator21u32::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIterator21u32::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator21u32 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator21u32::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIterator21u32::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator21u32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator21u32::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIterator21u32::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator21u32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IndexIterator21u64(IndexIterator<Kmer<21, u64>, u64>);
    impl ::pyo3::types::DerefToPyAny for IndexIterator21u64 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIterator21u64 {
        const NAME: &'static str = "IndexIterator21u64";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIterator21u64 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIterator21u64 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIterator21u64 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIterator21u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIterator21u64 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIterator21u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIterator21u64 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIterator21u64 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIterator21u64>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIterator21u64 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IndexIterator21u64>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIterator21u64> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator21u64 {}
    impl IndexIterator21u64 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator21u64 {}
    impl IndexIterator21u64 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(PyKmer21, u64)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((PyKmer21(index_entry.key.into()), index_entry.val))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIterator21u64>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIterator21u64> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIterator21u64::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIterator21u64::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator21u64 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator21u64::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIterator21u64::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator21u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator21u64::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIterator21u64::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator21u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IndexIterator21u128(IndexIterator<Kmer<21, u64>, u128>);
    impl ::pyo3::types::DerefToPyAny for IndexIterator21u128 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIterator21u128 {
        const NAME: &'static str = "IndexIterator21u128";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIterator21u128 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIterator21u128 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIterator21u128 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIterator21u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIterator21u128 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIterator21u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIterator21u128 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIterator21u128 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIterator21u128>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIterator21u128 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIterator21u128,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIterator21u128> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator21u128 {}
    impl IndexIterator21u128 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator21u128 {}
    impl IndexIterator21u128 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(PyKmer21, u128)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((PyKmer21(index_entry.key.into()), index_entry.val))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIterator21u128>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIterator21u128> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIterator21u128::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIterator21u128::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator21u128 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator21u128::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIterator21u128::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator21u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator21u128::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIterator21u128::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator21u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct KmerIndex21u8(pub KmerIndex<21, u64, u8>);
    #[automatically_derived]
    impl ::core::clone::Clone for KmerIndex21u8 {
        #[inline]
        fn clone(&self) -> KmerIndex21u8 {
            KmerIndex21u8(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for KmerIndex21u8 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for KmerIndex21u8 {
        const NAME: &'static str = "KmerIndex21u8";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <KmerIndex21u8 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for KmerIndex21u8 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a KmerIndex21u8 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, KmerIndex21u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut KmerIndex21u8 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, KmerIndex21u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for KmerIndex21u8 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for KmerIndex21u8 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<KmerIndex21u8>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for KmerIndex21u8 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<KmerIndex21u8>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<KmerIndex21u8> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex21u8 {}
    impl KmerIndex21u8 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex21u8 {}
    impl KmerIndex21u8 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let kmer_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let kmer: PyKmer21 = base_tuple
                                .get_item(0)?
                                .extract()
                                .unwrap();
                            let val: u8 = base_tuple.get_item(1)?.extract().unwrap();
                            Ok(KmerIndexEntry::<21, u64, u8> {
                                key: kmer.0.into(),
                                val,
                            })
                        })
                });
            Ok(
                Self(
                    KmerIndex::<
                        21,
                        u64,
                        u8,
                    >::build_index(
                            kmer_entry_iter.map(|e| e.unwrap()),
                            path,
                            buffer_size,
                        )
                        .unwrap(),
                ),
            )
        }
        /// Build the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)
        pub fn build_dna(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
            index: u64,
            modulo: u64,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let dna_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let dna: PyDNA = base_tuple.get_item(0)?.extract().unwrap();
                            let val: u8 = base_tuple.get_item(0)?.extract().unwrap();
                            Ok((dna, val))
                        })
                });
            let kmer_iter = dna_entry_iter
                .map(|e| e.unwrap())
                .flat_map(|(dna, val)| {
                    let kmer_it: CanonicalKmerIterator<21, u64> = (&dna.0).into();
                    let kmer_vec: Vec<KmerIndexEntry<21, u64, u8>> = kmer_it
                        .filter(|kmer| kmer.hash() % modulo == index)
                        .map(move |kmer| KmerIndexEntry::<21, u64, u8> {
                            key: kmer,
                            val,
                        })
                        .collect();
                    kmer_vec.into_iter()
                });
            Ok(
                Self(
                    KmerIndex::<21, u64, u8>::build_index(kmer_iter, path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn intersection_index(
            &self,
            other: &KmerSet21,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(IntSetu8(self.0.join_index::<()>(other.0.clone(), path, buffer_size)))
        }
        pub fn intersection_iter(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            Ok((i.extract::<PyKmer21>().unwrap().0.into(), ()))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntSetu8(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn get_all(&self, kmer: PyKmer21) -> PyResult<Vec<u8>> {
            match self.0.get_all(kmer.0.into()) {
                Ok(iter) => Ok(iter.collect()),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, kmer: PyKmer21) -> PyResult<u8> {
            match self.0.get(kmer.0.into()) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(KmerIndex::<21, u64, u8>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIterator21u8>> {
            let iter = IndexIterator21u8(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
        fn size() -> PyResult<usize> {
            Ok(21)
        }
        pub fn join_iteru8(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer21>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u8>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu8u8(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu8(
            &self,
            other: &KmerIndex21u8,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(IntIndexu8u8(self.0.join_index::<u8>(other.0.clone(), path, buffer_size)))
        }
        pub fn join_iteru16(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer21>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u16>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu8u16(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu16(
            &self,
            other: &KmerIndex21u16,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu8u16(
                    self.0.join_index::<u16>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru32(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer21>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u32>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu8u32(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu32(
            &self,
            other: &KmerIndex21u32,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu8u32(
                    self.0.join_index::<u32>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru64(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer21>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u64>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu8u64(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu64(
            &self,
            other: &KmerIndex21u64,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu8u64(
                    self.0.join_index::<u64>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru128(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer21>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u128>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu8u128(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu128(
            &self,
            other: &KmerIndex21u128,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu8u128(
                    self.0.join_index::<u128>(other.0.clone(), path, buffer_size),
                ),
            )
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<KmerIndex21u8>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<KmerIndex21u8> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex21u8::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build_dna",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex21u8::__pymethod_build_dna__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build_dna($cls, iterator, index_path, buffer_size, index, modulo)\n--\n\nBuild the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_index",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u8::__pymethod_intersection_index__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_index($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_iter",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u8::__pymethod_intersection_iter__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_iter($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"get_all",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u8::__pymethod_get_all__,
                                        )
                                    }
                                    trampoline
                                },
                                c"get_all($self, kmer)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Static(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                    c"size",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            unsafe {
                                                ::pyo3::impl_::trampoline::noargs(
                                                    _slf,
                                                    _args,
                                                    KmerIndex21u8::__pymethod_size__,
                                                )
                                            }
                                        }
                                        trampoline
                                    },
                                    c"size()\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_STATIC),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u8::__pymethod_join_iteru8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru8($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u8::__pymethod_join_indexu8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu8($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u8::__pymethod_join_iteru16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru16($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u8::__pymethod_join_indexu16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu16($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u8::__pymethod_join_iteru32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru32($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u8::__pymethod_join_indexu32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu32($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u8::__pymethod_join_iteru64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru64($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u8::__pymethod_join_indexu64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu64($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u8::__pymethod_join_iteru128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru128($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u8::__pymethod_join_indexu128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu128($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                KmerIndex21u8::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                KmerIndex21u8::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<KmerIndex21u8>
                                for PyClassImplCollector<KmerIndex21u8> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    KmerIndex21u8::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                KmerIndex21u8::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex21u8 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u8::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_build_dna__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u8::build_dna;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build_dna",
                positional_parameter_names: &[
                    "iterator",
                    "index_path",
                    "buffer_size",
                    "index",
                    "modulo",
                ],
                positional_only_parameters: 0usize,
                required_positional_parameters: 5usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 5usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_4 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[3usize].as_deref(),
                            )
                        },
                        &mut holder_3,
                        "index",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[4usize].as_deref(),
                            )
                        },
                        &mut holder_4,
                        "modulo",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_index__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u8::intersection_index;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_index",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_iter__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u8::intersection_iter;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_iter",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_get_all__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u8::get_all;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "get_all",
                positional_parameter_names: &["kmer"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "kmer",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = KmerIndex21u8::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex21u8::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex21u8,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u8::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex21u8::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex21u8,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "kmer",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = KmerIndex21u8::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex21u8::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<KmerIndex21u8> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u8::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = KmerIndex21u8::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<KmerIndex21u8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod_size__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u8::size;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function();
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u8::join_iteru8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru8",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u8::join_indexu8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu8",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u8::join_iteru16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru16",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u8::join_indexu16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu16",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u8::join_iteru32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru32",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u8::join_indexu32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu32",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u8::join_iteru64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru64",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u8::join_indexu64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu64",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u8::join_iteru128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru128",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u8::join_indexu128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu128",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
    }
    pub struct KmerIndex21u16(pub KmerIndex<21, u64, u16>);
    #[automatically_derived]
    impl ::core::clone::Clone for KmerIndex21u16 {
        #[inline]
        fn clone(&self) -> KmerIndex21u16 {
            KmerIndex21u16(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for KmerIndex21u16 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for KmerIndex21u16 {
        const NAME: &'static str = "KmerIndex21u16";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <KmerIndex21u16 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for KmerIndex21u16 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a KmerIndex21u16 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, KmerIndex21u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut KmerIndex21u16 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, KmerIndex21u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for KmerIndex21u16 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for KmerIndex21u16 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<KmerIndex21u16>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for KmerIndex21u16 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<KmerIndex21u16>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<KmerIndex21u16> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex21u16 {}
    impl KmerIndex21u16 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex21u16 {}
    impl KmerIndex21u16 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let kmer_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let kmer: PyKmer21 = base_tuple
                                .get_item(0)?
                                .extract()
                                .unwrap();
                            let val: u16 = base_tuple.get_item(1)?.extract().unwrap();
                            Ok(KmerIndexEntry::<21, u64, u16> {
                                key: kmer.0.into(),
                                val,
                            })
                        })
                });
            Ok(
                Self(
                    KmerIndex::<
                        21,
                        u64,
                        u16,
                    >::build_index(
                            kmer_entry_iter.map(|e| e.unwrap()),
                            path,
                            buffer_size,
                        )
                        .unwrap(),
                ),
            )
        }
        /// Build the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)
        pub fn build_dna(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
            index: u64,
            modulo: u64,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let dna_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let dna: PyDNA = base_tuple.get_item(0)?.extract().unwrap();
                            let val: u16 = base_tuple.get_item(0)?.extract().unwrap();
                            Ok((dna, val))
                        })
                });
            let kmer_iter = dna_entry_iter
                .map(|e| e.unwrap())
                .flat_map(|(dna, val)| {
                    let kmer_it: CanonicalKmerIterator<21, u64> = (&dna.0).into();
                    let kmer_vec: Vec<KmerIndexEntry<21, u64, u16>> = kmer_it
                        .filter(|kmer| kmer.hash() % modulo == index)
                        .map(move |kmer| KmerIndexEntry::<21, u64, u16> {
                            key: kmer,
                            val,
                        })
                        .collect();
                    kmer_vec.into_iter()
                });
            Ok(
                Self(
                    KmerIndex::<21, u64, u16>::build_index(kmer_iter, path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn intersection_index(
            &self,
            other: &KmerSet21,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(IntSetu16(self.0.join_index::<()>(other.0.clone(), path, buffer_size)))
        }
        pub fn intersection_iter(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            Ok((i.extract::<PyKmer21>().unwrap().0.into(), ()))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntSetu16(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn get_all(&self, kmer: PyKmer21) -> PyResult<Vec<u16>> {
            match self.0.get_all(kmer.0.into()) {
                Ok(iter) => Ok(iter.collect()),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, kmer: PyKmer21) -> PyResult<u16> {
            match self.0.get(kmer.0.into()) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(KmerIndex::<21, u64, u16>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIterator21u16>> {
            let iter = IndexIterator21u16(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
        fn size() -> PyResult<usize> {
            Ok(21)
        }
        pub fn join_iteru8(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer21>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u8>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu16u8(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu8(
            &self,
            other: &KmerIndex21u8,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu16u8(
                    self.0.join_index::<u8>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru16(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer21>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u16>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu16u16(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu16(
            &self,
            other: &KmerIndex21u16,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu16u16(
                    self.0.join_index::<u16>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru32(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer21>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u32>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu16u32(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu32(
            &self,
            other: &KmerIndex21u32,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu16u32(
                    self.0.join_index::<u32>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru64(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer21>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u64>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu16u64(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu64(
            &self,
            other: &KmerIndex21u64,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu16u64(
                    self.0.join_index::<u64>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru128(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer21>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u128>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu16u128(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu128(
            &self,
            other: &KmerIndex21u128,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu16u128(
                    self.0.join_index::<u128>(other.0.clone(), path, buffer_size),
                ),
            )
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<KmerIndex21u16>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<KmerIndex21u16> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex21u16::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build_dna",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex21u16::__pymethod_build_dna__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build_dna($cls, iterator, index_path, buffer_size, index, modulo)\n--\n\nBuild the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_index",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u16::__pymethod_intersection_index__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_index($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_iter",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u16::__pymethod_intersection_iter__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_iter($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"get_all",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u16::__pymethod_get_all__,
                                        )
                                    }
                                    trampoline
                                },
                                c"get_all($self, kmer)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Static(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                    c"size",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            unsafe {
                                                ::pyo3::impl_::trampoline::noargs(
                                                    _slf,
                                                    _args,
                                                    KmerIndex21u16::__pymethod_size__,
                                                )
                                            }
                                        }
                                        trampoline
                                    },
                                    c"size()\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_STATIC),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u16::__pymethod_join_iteru8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru8($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u16::__pymethod_join_indexu8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu8($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u16::__pymethod_join_iteru16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru16($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u16::__pymethod_join_indexu16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu16($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u16::__pymethod_join_iteru32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru32($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u16::__pymethod_join_indexu32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu32($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u16::__pymethod_join_iteru64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru64($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u16::__pymethod_join_indexu64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu64($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u16::__pymethod_join_iteru128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru128($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u16::__pymethod_join_indexu128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu128($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                KmerIndex21u16::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                KmerIndex21u16::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<KmerIndex21u16>
                                for PyClassImplCollector<KmerIndex21u16> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    KmerIndex21u16::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                KmerIndex21u16::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex21u16 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u16::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_build_dna__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u16::build_dna;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build_dna",
                positional_parameter_names: &[
                    "iterator",
                    "index_path",
                    "buffer_size",
                    "index",
                    "modulo",
                ],
                positional_only_parameters: 0usize,
                required_positional_parameters: 5usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 5usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_4 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[3usize].as_deref(),
                            )
                        },
                        &mut holder_3,
                        "index",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[4usize].as_deref(),
                            )
                        },
                        &mut holder_4,
                        "modulo",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_index__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u16::intersection_index;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_index",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_iter__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u16::intersection_iter;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_iter",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_get_all__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u16::get_all;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "get_all",
                positional_parameter_names: &["kmer"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "kmer",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = KmerIndex21u16::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex21u16::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex21u16,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u16::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex21u16::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex21u16,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "kmer",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = KmerIndex21u16::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex21u16::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<KmerIndex21u16> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u16::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = KmerIndex21u16::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<KmerIndex21u16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod_size__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u16::size;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function();
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u16::join_iteru8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru8",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u16::join_indexu8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu8",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u16::join_iteru16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru16",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u16::join_indexu16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu16",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u16::join_iteru32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru32",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u16::join_indexu32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu32",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u16::join_iteru64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru64",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u16::join_indexu64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu64",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u16::join_iteru128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru128",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u16::join_indexu128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu128",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
    }
    pub struct KmerIndex21u32(pub KmerIndex<21, u64, u32>);
    #[automatically_derived]
    impl ::core::clone::Clone for KmerIndex21u32 {
        #[inline]
        fn clone(&self) -> KmerIndex21u32 {
            KmerIndex21u32(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for KmerIndex21u32 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for KmerIndex21u32 {
        const NAME: &'static str = "KmerIndex21u32";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <KmerIndex21u32 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for KmerIndex21u32 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a KmerIndex21u32 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, KmerIndex21u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut KmerIndex21u32 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, KmerIndex21u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for KmerIndex21u32 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for KmerIndex21u32 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<KmerIndex21u32>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for KmerIndex21u32 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<KmerIndex21u32>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<KmerIndex21u32> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex21u32 {}
    impl KmerIndex21u32 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex21u32 {}
    impl KmerIndex21u32 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let kmer_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let kmer: PyKmer21 = base_tuple
                                .get_item(0)?
                                .extract()
                                .unwrap();
                            let val: u32 = base_tuple.get_item(1)?.extract().unwrap();
                            Ok(KmerIndexEntry::<21, u64, u32> {
                                key: kmer.0.into(),
                                val,
                            })
                        })
                });
            Ok(
                Self(
                    KmerIndex::<
                        21,
                        u64,
                        u32,
                    >::build_index(
                            kmer_entry_iter.map(|e| e.unwrap()),
                            path,
                            buffer_size,
                        )
                        .unwrap(),
                ),
            )
        }
        /// Build the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)
        pub fn build_dna(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
            index: u64,
            modulo: u64,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let dna_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let dna: PyDNA = base_tuple.get_item(0)?.extract().unwrap();
                            let val: u32 = base_tuple.get_item(0)?.extract().unwrap();
                            Ok((dna, val))
                        })
                });
            let kmer_iter = dna_entry_iter
                .map(|e| e.unwrap())
                .flat_map(|(dna, val)| {
                    let kmer_it: CanonicalKmerIterator<21, u64> = (&dna.0).into();
                    let kmer_vec: Vec<KmerIndexEntry<21, u64, u32>> = kmer_it
                        .filter(|kmer| kmer.hash() % modulo == index)
                        .map(move |kmer| KmerIndexEntry::<21, u64, u32> {
                            key: kmer,
                            val,
                        })
                        .collect();
                    kmer_vec.into_iter()
                });
            Ok(
                Self(
                    KmerIndex::<21, u64, u32>::build_index(kmer_iter, path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn intersection_index(
            &self,
            other: &KmerSet21,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(IntSetu32(self.0.join_index::<()>(other.0.clone(), path, buffer_size)))
        }
        pub fn intersection_iter(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            Ok((i.extract::<PyKmer21>().unwrap().0.into(), ()))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntSetu32(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn get_all(&self, kmer: PyKmer21) -> PyResult<Vec<u32>> {
            match self.0.get_all(kmer.0.into()) {
                Ok(iter) => Ok(iter.collect()),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, kmer: PyKmer21) -> PyResult<u32> {
            match self.0.get(kmer.0.into()) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(KmerIndex::<21, u64, u32>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIterator21u32>> {
            let iter = IndexIterator21u32(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
        fn size() -> PyResult<usize> {
            Ok(21)
        }
        pub fn join_iteru8(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer21>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u8>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu32u8(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu8(
            &self,
            other: &KmerIndex21u8,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu32u8(
                    self.0.join_index::<u8>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru16(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer21>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u16>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu32u16(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu16(
            &self,
            other: &KmerIndex21u16,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu32u16(
                    self.0.join_index::<u16>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru32(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer21>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u32>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu32u32(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu32(
            &self,
            other: &KmerIndex21u32,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu32u32(
                    self.0.join_index::<u32>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru64(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer21>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u64>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu32u64(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu64(
            &self,
            other: &KmerIndex21u64,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu32u64(
                    self.0.join_index::<u64>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru128(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer21>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u128>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu32u128(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu128(
            &self,
            other: &KmerIndex21u128,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu32u128(
                    self.0.join_index::<u128>(other.0.clone(), path, buffer_size),
                ),
            )
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<KmerIndex21u32>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<KmerIndex21u32> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex21u32::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build_dna",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex21u32::__pymethod_build_dna__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build_dna($cls, iterator, index_path, buffer_size, index, modulo)\n--\n\nBuild the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_index",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u32::__pymethod_intersection_index__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_index($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_iter",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u32::__pymethod_intersection_iter__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_iter($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"get_all",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u32::__pymethod_get_all__,
                                        )
                                    }
                                    trampoline
                                },
                                c"get_all($self, kmer)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Static(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                    c"size",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            unsafe {
                                                ::pyo3::impl_::trampoline::noargs(
                                                    _slf,
                                                    _args,
                                                    KmerIndex21u32::__pymethod_size__,
                                                )
                                            }
                                        }
                                        trampoline
                                    },
                                    c"size()\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_STATIC),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u32::__pymethod_join_iteru8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru8($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u32::__pymethod_join_indexu8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu8($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u32::__pymethod_join_iteru16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru16($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u32::__pymethod_join_indexu16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu16($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u32::__pymethod_join_iteru32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru32($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u32::__pymethod_join_indexu32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu32($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u32::__pymethod_join_iteru64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru64($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u32::__pymethod_join_indexu64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu64($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u32::__pymethod_join_iteru128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru128($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u32::__pymethod_join_indexu128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu128($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                KmerIndex21u32::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                KmerIndex21u32::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<KmerIndex21u32>
                                for PyClassImplCollector<KmerIndex21u32> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    KmerIndex21u32::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                KmerIndex21u32::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex21u32 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u32::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_build_dna__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u32::build_dna;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build_dna",
                positional_parameter_names: &[
                    "iterator",
                    "index_path",
                    "buffer_size",
                    "index",
                    "modulo",
                ],
                positional_only_parameters: 0usize,
                required_positional_parameters: 5usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 5usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_4 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[3usize].as_deref(),
                            )
                        },
                        &mut holder_3,
                        "index",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[4usize].as_deref(),
                            )
                        },
                        &mut holder_4,
                        "modulo",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_index__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u32::intersection_index;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_index",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_iter__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u32::intersection_iter;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_iter",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_get_all__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u32::get_all;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "get_all",
                positional_parameter_names: &["kmer"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "kmer",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = KmerIndex21u32::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex21u32::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex21u32,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u32::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex21u32::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex21u32,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "kmer",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = KmerIndex21u32::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex21u32::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<KmerIndex21u32> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u32::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = KmerIndex21u32::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<KmerIndex21u32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod_size__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u32::size;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function();
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u32::join_iteru8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru8",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u32::join_indexu8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu8",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u32::join_iteru16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru16",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u32::join_indexu16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu16",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u32::join_iteru32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru32",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u32::join_indexu32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu32",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u32::join_iteru64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru64",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u32::join_indexu64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu64",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u32::join_iteru128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru128",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u32::join_indexu128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu128",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
    }
    pub struct KmerIndex21u64(pub KmerIndex<21, u64, u64>);
    #[automatically_derived]
    impl ::core::clone::Clone for KmerIndex21u64 {
        #[inline]
        fn clone(&self) -> KmerIndex21u64 {
            KmerIndex21u64(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for KmerIndex21u64 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for KmerIndex21u64 {
        const NAME: &'static str = "KmerIndex21u64";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <KmerIndex21u64 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for KmerIndex21u64 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a KmerIndex21u64 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, KmerIndex21u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut KmerIndex21u64 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, KmerIndex21u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for KmerIndex21u64 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for KmerIndex21u64 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<KmerIndex21u64>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for KmerIndex21u64 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<KmerIndex21u64>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<KmerIndex21u64> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex21u64 {}
    impl KmerIndex21u64 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex21u64 {}
    impl KmerIndex21u64 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let kmer_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let kmer: PyKmer21 = base_tuple
                                .get_item(0)?
                                .extract()
                                .unwrap();
                            let val: u64 = base_tuple.get_item(1)?.extract().unwrap();
                            Ok(KmerIndexEntry::<21, u64, u64> {
                                key: kmer.0.into(),
                                val,
                            })
                        })
                });
            Ok(
                Self(
                    KmerIndex::<
                        21,
                        u64,
                        u64,
                    >::build_index(
                            kmer_entry_iter.map(|e| e.unwrap()),
                            path,
                            buffer_size,
                        )
                        .unwrap(),
                ),
            )
        }
        /// Build the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)
        pub fn build_dna(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
            index: u64,
            modulo: u64,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let dna_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let dna: PyDNA = base_tuple.get_item(0)?.extract().unwrap();
                            let val: u64 = base_tuple.get_item(0)?.extract().unwrap();
                            Ok((dna, val))
                        })
                });
            let kmer_iter = dna_entry_iter
                .map(|e| e.unwrap())
                .flat_map(|(dna, val)| {
                    let kmer_it: CanonicalKmerIterator<21, u64> = (&dna.0).into();
                    let kmer_vec: Vec<KmerIndexEntry<21, u64, u64>> = kmer_it
                        .filter(|kmer| kmer.hash() % modulo == index)
                        .map(move |kmer| KmerIndexEntry::<21, u64, u64> {
                            key: kmer,
                            val,
                        })
                        .collect();
                    kmer_vec.into_iter()
                });
            Ok(
                Self(
                    KmerIndex::<21, u64, u64>::build_index(kmer_iter, path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn intersection_index(
            &self,
            other: &KmerSet21,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(IntSetu64(self.0.join_index::<()>(other.0.clone(), path, buffer_size)))
        }
        pub fn intersection_iter(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            Ok((i.extract::<PyKmer21>().unwrap().0.into(), ()))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntSetu64(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn get_all(&self, kmer: PyKmer21) -> PyResult<Vec<u64>> {
            match self.0.get_all(kmer.0.into()) {
                Ok(iter) => Ok(iter.collect()),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, kmer: PyKmer21) -> PyResult<u64> {
            match self.0.get(kmer.0.into()) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(KmerIndex::<21, u64, u64>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIterator21u64>> {
            let iter = IndexIterator21u64(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
        fn size() -> PyResult<usize> {
            Ok(21)
        }
        pub fn join_iteru8(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer21>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u8>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu64u8(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu8(
            &self,
            other: &KmerIndex21u8,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu64u8(
                    self.0.join_index::<u8>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru16(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer21>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u16>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu64u16(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu16(
            &self,
            other: &KmerIndex21u16,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu64u16(
                    self.0.join_index::<u16>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru32(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer21>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u32>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu64u32(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu32(
            &self,
            other: &KmerIndex21u32,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu64u32(
                    self.0.join_index::<u32>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru64(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer21>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u64>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu64u64(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu64(
            &self,
            other: &KmerIndex21u64,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu64u64(
                    self.0.join_index::<u64>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru128(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer21>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u128>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu64u128(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu128(
            &self,
            other: &KmerIndex21u128,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu64u128(
                    self.0.join_index::<u128>(other.0.clone(), path, buffer_size),
                ),
            )
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<KmerIndex21u64>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<KmerIndex21u64> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex21u64::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build_dna",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex21u64::__pymethod_build_dna__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build_dna($cls, iterator, index_path, buffer_size, index, modulo)\n--\n\nBuild the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_index",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u64::__pymethod_intersection_index__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_index($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_iter",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u64::__pymethod_intersection_iter__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_iter($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"get_all",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u64::__pymethod_get_all__,
                                        )
                                    }
                                    trampoline
                                },
                                c"get_all($self, kmer)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Static(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                    c"size",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            unsafe {
                                                ::pyo3::impl_::trampoline::noargs(
                                                    _slf,
                                                    _args,
                                                    KmerIndex21u64::__pymethod_size__,
                                                )
                                            }
                                        }
                                        trampoline
                                    },
                                    c"size()\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_STATIC),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u64::__pymethod_join_iteru8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru8($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u64::__pymethod_join_indexu8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu8($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u64::__pymethod_join_iteru16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru16($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u64::__pymethod_join_indexu16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu16($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u64::__pymethod_join_iteru32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru32($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u64::__pymethod_join_indexu32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu32($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u64::__pymethod_join_iteru64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru64($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u64::__pymethod_join_indexu64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu64($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u64::__pymethod_join_iteru128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru128($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u64::__pymethod_join_indexu128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu128($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                KmerIndex21u64::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                KmerIndex21u64::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<KmerIndex21u64>
                                for PyClassImplCollector<KmerIndex21u64> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    KmerIndex21u64::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                KmerIndex21u64::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex21u64 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u64::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_build_dna__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u64::build_dna;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build_dna",
                positional_parameter_names: &[
                    "iterator",
                    "index_path",
                    "buffer_size",
                    "index",
                    "modulo",
                ],
                positional_only_parameters: 0usize,
                required_positional_parameters: 5usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 5usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_4 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[3usize].as_deref(),
                            )
                        },
                        &mut holder_3,
                        "index",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[4usize].as_deref(),
                            )
                        },
                        &mut holder_4,
                        "modulo",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_index__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u64::intersection_index;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_index",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_iter__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u64::intersection_iter;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_iter",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_get_all__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u64::get_all;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "get_all",
                positional_parameter_names: &["kmer"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "kmer",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = KmerIndex21u64::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex21u64::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex21u64,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u64::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex21u64::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex21u64,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "kmer",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = KmerIndex21u64::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex21u64::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<KmerIndex21u64> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u64::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = KmerIndex21u64::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<KmerIndex21u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod_size__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u64::size;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function();
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u64::join_iteru8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru8",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u64::join_indexu8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu8",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u64::join_iteru16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru16",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u64::join_indexu16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu16",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u64::join_iteru32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru32",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u64::join_indexu32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu32",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u64::join_iteru64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru64",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u64::join_indexu64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu64",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u64::join_iteru128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru128",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u64::join_indexu128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu128",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
    }
    pub struct KmerIndex21u128(pub KmerIndex<21, u64, u128>);
    #[automatically_derived]
    impl ::core::clone::Clone for KmerIndex21u128 {
        #[inline]
        fn clone(&self) -> KmerIndex21u128 {
            KmerIndex21u128(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for KmerIndex21u128 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for KmerIndex21u128 {
        const NAME: &'static str = "KmerIndex21u128";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <KmerIndex21u128 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for KmerIndex21u128 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a KmerIndex21u128 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, KmerIndex21u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut KmerIndex21u128 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, KmerIndex21u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for KmerIndex21u128 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for KmerIndex21u128 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<KmerIndex21u128>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for KmerIndex21u128 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<KmerIndex21u128>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<KmerIndex21u128> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex21u128 {}
    impl KmerIndex21u128 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex21u128 {}
    impl KmerIndex21u128 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let kmer_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let kmer: PyKmer21 = base_tuple
                                .get_item(0)?
                                .extract()
                                .unwrap();
                            let val: u128 = base_tuple.get_item(1)?.extract().unwrap();
                            Ok(KmerIndexEntry::<21, u64, u128> {
                                key: kmer.0.into(),
                                val,
                            })
                        })
                });
            Ok(
                Self(
                    KmerIndex::<
                        21,
                        u64,
                        u128,
                    >::build_index(
                            kmer_entry_iter.map(|e| e.unwrap()),
                            path,
                            buffer_size,
                        )
                        .unwrap(),
                ),
            )
        }
        /// Build the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)
        pub fn build_dna(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
            index: u64,
            modulo: u64,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let dna_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let dna: PyDNA = base_tuple.get_item(0)?.extract().unwrap();
                            let val: u128 = base_tuple.get_item(0)?.extract().unwrap();
                            Ok((dna, val))
                        })
                });
            let kmer_iter = dna_entry_iter
                .map(|e| e.unwrap())
                .flat_map(|(dna, val)| {
                    let kmer_it: CanonicalKmerIterator<21, u64> = (&dna.0).into();
                    let kmer_vec: Vec<KmerIndexEntry<21, u64, u128>> = kmer_it
                        .filter(|kmer| kmer.hash() % modulo == index)
                        .map(move |kmer| KmerIndexEntry::<21, u64, u128> {
                            key: kmer,
                            val,
                        })
                        .collect();
                    kmer_vec.into_iter()
                });
            Ok(
                Self(
                    KmerIndex::<21, u64, u128>::build_index(kmer_iter, path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn intersection_index(
            &self,
            other: &KmerSet21,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(IntSetu128(self.0.join_index::<()>(other.0.clone(), path, buffer_size)))
        }
        pub fn intersection_iter(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            Ok((i.extract::<PyKmer21>().unwrap().0.into(), ()))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntSetu128(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn get_all(&self, kmer: PyKmer21) -> PyResult<Vec<u128>> {
            match self.0.get_all(kmer.0.into()) {
                Ok(iter) => Ok(iter.collect()),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, kmer: PyKmer21) -> PyResult<u128> {
            match self.0.get(kmer.0.into()) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(KmerIndex::<21, u64, u128>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIterator21u128>> {
            let iter = IndexIterator21u128(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
        fn size() -> PyResult<usize> {
            Ok(21)
        }
        pub fn join_iteru8(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer21>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u8>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu128u8(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu8(
            &self,
            other: &KmerIndex21u8,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu128u8(
                    self.0.join_index::<u8>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru16(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer21>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u16>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu128u16(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu16(
            &self,
            other: &KmerIndex21u16,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu128u16(
                    self.0.join_index::<u16>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru32(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer21>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u32>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu128u32(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu32(
            &self,
            other: &KmerIndex21u32,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu128u32(
                    self.0.join_index::<u32>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru64(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer21>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u64>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu128u64(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu64(
            &self,
            other: &KmerIndex21u64,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu128u64(
                    self.0.join_index::<u64>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru128(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer21>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u128>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu128u128(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu128(
            &self,
            other: &KmerIndex21u128,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu128u128(
                    self.0.join_index::<u128>(other.0.clone(), path, buffer_size),
                ),
            )
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<KmerIndex21u128>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<KmerIndex21u128> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex21u128::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build_dna",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex21u128::__pymethod_build_dna__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build_dna($cls, iterator, index_path, buffer_size, index, modulo)\n--\n\nBuild the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_index",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u128::__pymethod_intersection_index__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_index($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_iter",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u128::__pymethod_intersection_iter__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_iter($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"get_all",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u128::__pymethod_get_all__,
                                        )
                                    }
                                    trampoline
                                },
                                c"get_all($self, kmer)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Static(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                    c"size",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            unsafe {
                                                ::pyo3::impl_::trampoline::noargs(
                                                    _slf,
                                                    _args,
                                                    KmerIndex21u128::__pymethod_size__,
                                                )
                                            }
                                        }
                                        trampoline
                                    },
                                    c"size()\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_STATIC),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u128::__pymethod_join_iteru8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru8($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u128::__pymethod_join_indexu8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu8($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u128::__pymethod_join_iteru16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru16($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u128::__pymethod_join_indexu16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu16($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u128::__pymethod_join_iteru32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru32($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u128::__pymethod_join_indexu32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu32($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u128::__pymethod_join_iteru64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru64($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u128::__pymethod_join_indexu64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu64($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u128::__pymethod_join_iteru128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru128($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex21u128::__pymethod_join_indexu128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu128($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                KmerIndex21u128::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                KmerIndex21u128::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<KmerIndex21u128>
                                for PyClassImplCollector<KmerIndex21u128> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    KmerIndex21u128::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                KmerIndex21u128::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex21u128 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u128::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_build_dna__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u128::build_dna;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build_dna",
                positional_parameter_names: &[
                    "iterator",
                    "index_path",
                    "buffer_size",
                    "index",
                    "modulo",
                ],
                positional_only_parameters: 0usize,
                required_positional_parameters: 5usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 5usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_4 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[3usize].as_deref(),
                            )
                        },
                        &mut holder_3,
                        "index",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[4usize].as_deref(),
                            )
                        },
                        &mut holder_4,
                        "modulo",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_index__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u128::intersection_index;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_index",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_iter__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u128::intersection_iter;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_iter",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_get_all__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u128::get_all;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "get_all",
                positional_parameter_names: &["kmer"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "kmer",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = KmerIndex21u128::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex21u128::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex21u128,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u128::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex21u128::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex21u128,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "kmer",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = KmerIndex21u128::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex21u128::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<KmerIndex21u128> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u128::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = KmerIndex21u128::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<KmerIndex21u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod_size__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u128::size;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function();
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u128::join_iteru8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru8",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u128::join_indexu8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu8",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u128::join_iteru16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru16",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u128::join_indexu16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu16",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u128::join_iteru32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru32",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u128::join_indexu32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu32",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u128::join_iteru64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru64",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u128::join_indexu64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu64",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u128::join_iteru128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru128",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex21u128::join_indexu128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex21u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu128",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex21u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
    }
    m.add_class::<PyKmer21>()?;
    m.add_class::<KmerSet21>()?;
    m.add_class::<KmerIndex21u8>()?;
    m.add_class::<KmerIndex21u16>()?;
    m.add_class::<KmerIndex21u32>()?;
    m.add_class::<KmerIndex21u64>()?;
    m.add_class::<KmerIndex21u128>()?;
    pub struct PyKmer55(pub PyKmer<55, u128>);
    #[automatically_derived]
    impl ::core::clone::Clone for PyKmer55 {
        #[inline]
        fn clone(&self) -> PyKmer55 {
            PyKmer55(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for PyKmer55 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for PyKmer55 {
        const NAME: &'static str = "PyKmer55";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <PyKmer55 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for PyKmer55 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a PyKmer55 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, PyKmer55>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut PyKmer55 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, PyKmer55>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for PyKmer55 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for PyKmer55 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<PyKmer55>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for PyKmer55 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<PyKmer55>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<PyKmer55> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl PyKmer55 {}
    impl PyKmer55 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl PyKmer55 {}
    impl PyKmer55 {
        pub fn new(data: u128) -> PyResult<Self> {
            Ok(Self(PyKmer::<55, u128>(Kmer::<55, u128>(data.into()))))
        }
        pub fn enumerate_canonical_kmer(
            _: &Bound<'_, PyType>,
            dna: PyDNA,
        ) -> PyResult<Vec<Self>> {
            let it: CanonicalKmerIterator<55, u128> = (&(dna.0)).try_into().unwrap();
            Ok(it.map(|u| Self(u.into())).collect())
        }
        pub fn count__kmer(_: &Bound<'_, PyType>, dna: PyDNA) -> PyResult<usize> {
            let it: KmerIterator<55, u128> = (&(dna.0)).try_into().unwrap();
            Ok(it.count())
        }
        pub fn enumerate_kmer(_: &Bound<'_, PyType>, dna: PyDNA) -> PyResult<Vec<Self>> {
            let it: KmerIterator<55, u128> = (&(dna.0)).try_into().unwrap();
            Ok(it.map(|u| Self(u.into())).collect())
        }
        pub fn size() -> PyResult<usize> {
            Ok(55)
        }
        pub fn add_left_nucleotid(&self, n: PyNucleotid) -> PyResult<Self> {
            Ok(Self(self.0.0.append_left(n.0).into()))
        }
        pub fn add_right_nucleotid(&self, n: PyNucleotid) -> PyResult<Self> {
            Ok(Self(self.0.0.append(n.0).into()))
        }
        pub fn reverse_complement(&self) -> PyResult<Self> {
            Ok(Self(self.0.0.rc().into()))
        }
        pub fn canonical(&self) -> PyResult<Self> {
            Ok(Self(self.0.0.normalize().into()))
        }
        pub fn is_canonical(&self) -> PyResult<bool> {
            Ok(self.0.0 == self.0.0.normalize())
        }
        pub fn data(&self) -> PyResult<u128> {
            Ok(self.0.0.get_data().into())
        }
        pub fn __hash__(&self) -> PyResult<u64> {
            Ok(self.0.0.hash())
        }
        pub fn __repr__(&self) -> PyResult<String> {
            Ok(
                ::alloc::__export::must_use({
                    let res = ::alloc::fmt::format(format_args!("{0}", &self.0.0));
                    res
                }),
            )
        }
        pub fn __str__(&self) -> PyResult<String> {
            Ok((&self.0.0).into())
        }
        pub fn __lt__(&self, other: Self) -> PyResult<bool> {
            Ok(self.0.0 <= other.0.0)
        }
        pub fn __gt__(&self, other: Self) -> PyResult<bool> {
            Ok(self.0.0 >= other.0.0)
        }
        pub fn __eq__(&self, other: Self) -> PyResult<bool> {
            Ok(self.0.0 == other.0.0)
        }
    }
    impl PyKmer55 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___lt____(
            py: ::pyo3::Python,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyKmer55::__lt__(
                match ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    PyKmer55,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                ) {
                    ::std::result::Result::Ok(value) => value,
                    ::std::result::Result::Err(_) => {
                        return ::pyo3::impl_::callback::convert(py, py.NotImplemented());
                    }
                },
                match ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "other",
                ) {
                    ::std::result::Result::Ok(value) => value,
                    ::std::result::Result::Err(_) => {
                        return ::pyo3::impl_::callback::convert(py, py.NotImplemented());
                    }
                },
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    impl ::pyo3::impl_::pyclass::PyClass__lt__SlotFragment<PyKmer55>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<PyKmer55> {
        #[inline]
        unsafe fn __lt__(
            self,
            py: ::pyo3::Python,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            PyKmer55::__pymethod___lt____(py, _raw_slf, arg0)
        }
    }
    impl PyKmer55 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___gt____(
            py: ::pyo3::Python,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyKmer55::__gt__(
                match ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    PyKmer55,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                ) {
                    ::std::result::Result::Ok(value) => value,
                    ::std::result::Result::Err(_) => {
                        return ::pyo3::impl_::callback::convert(py, py.NotImplemented());
                    }
                },
                match ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "other",
                ) {
                    ::std::result::Result::Ok(value) => value,
                    ::std::result::Result::Err(_) => {
                        return ::pyo3::impl_::callback::convert(py, py.NotImplemented());
                    }
                },
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    impl ::pyo3::impl_::pyclass::PyClass__gt__SlotFragment<PyKmer55>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<PyKmer55> {
        #[inline]
        unsafe fn __gt__(
            self,
            py: ::pyo3::Python,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            PyKmer55::__pymethod___gt____(py, _raw_slf, arg0)
        }
    }
    impl PyKmer55 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___eq____(
            py: ::pyo3::Python,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyKmer55::__eq__(
                match ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    PyKmer55,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                ) {
                    ::std::result::Result::Ok(value) => value,
                    ::std::result::Result::Err(_) => {
                        return ::pyo3::impl_::callback::convert(py, py.NotImplemented());
                    }
                },
                match ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "other",
                ) {
                    ::std::result::Result::Ok(value) => value,
                    ::std::result::Result::Err(_) => {
                        return ::pyo3::impl_::callback::convert(py, py.NotImplemented());
                    }
                },
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    impl ::pyo3::impl_::pyclass::PyClass__eq__SlotFragment<PyKmer55>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<PyKmer55> {
        #[inline]
        unsafe fn __eq__(
            self,
            py: ::pyo3::Python,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            PyKmer55::__pymethod___eq____(py, _raw_slf, arg0)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<PyKmer55>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<PyKmer55> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"enumerate_canonical_kmer",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                PyKmer55::__pymethod_enumerate_canonical_kmer__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"enumerate_canonical_kmer($cls, dna)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"count__kmer",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                PyKmer55::__pymethod_count__kmer__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"count__kmer($cls, dna)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"enumerate_kmer",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                PyKmer55::__pymethod_enumerate_kmer__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"enumerate_kmer($cls, dna)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Static(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                    c"size",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            unsafe {
                                                ::pyo3::impl_::trampoline::noargs(
                                                    _slf,
                                                    _args,
                                                    PyKmer55::__pymethod_size__,
                                                )
                                            }
                                        }
                                        trampoline
                                    },
                                    c"size()\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_STATIC),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"add_left_nucleotid",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            PyKmer55::__pymethod_add_left_nucleotid__,
                                        )
                                    }
                                    trampoline
                                },
                                c"add_left_nucleotid($self, n)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"add_right_nucleotid",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            PyKmer55::__pymethod_add_right_nucleotid__,
                                        )
                                    }
                                    trampoline
                                },
                                c"add_right_nucleotid($self, n)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                c"reverse_complement",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        unsafe {
                                            ::pyo3::impl_::trampoline::noargs(
                                                _slf,
                                                _args,
                                                PyKmer55::__pymethod_reverse_complement__,
                                            )
                                        }
                                    }
                                    trampoline
                                },
                                c"reverse_complement($self)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                c"canonical",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        unsafe {
                                            ::pyo3::impl_::trampoline::noargs(
                                                _slf,
                                                _args,
                                                PyKmer55::__pymethod_canonical__,
                                            )
                                        }
                                    }
                                    trampoline
                                },
                                c"canonical($self)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                c"is_canonical",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        unsafe {
                                            ::pyo3::impl_::trampoline::noargs(
                                                _slf,
                                                _args,
                                                PyKmer55::__pymethod_is_canonical__,
                                            )
                                        }
                                    }
                                    trampoline
                                },
                                c"is_canonical($self)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Getter(
                            ::pyo3::impl_::pymethods::PyGetterDef::new(
                                c"data",
                                PyKmer55::__pymethod_get_data__,
                                c"",
                            ),
                        ),
                    ),
                ],
                slots: &[
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<PyKmer55>
                                for PyClassImplCollector<PyKmer55> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(data)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    PyKmer55::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_hash_t {
                            ::pyo3::impl_::trampoline::hashfunc(
                                _slf,
                                PyKmer55::__pymethod___hash____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_hash,
                            pfunc: trampoline as ::pyo3::ffi::hashfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::reprfunc(
                                _slf,
                                PyKmer55::__pymethod___repr____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_repr,
                            pfunc: trampoline as ::pyo3::ffi::reprfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::reprfunc(
                                _slf,
                                PyKmer55::__pymethod___str____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_str,
                            pfunc: trampoline as ::pyo3::ffi::reprfunc as _,
                        }
                    },
                    {
                        #[allow(unknown_lints, non_local_definitions)]
                        impl PyKmer55 {
                            #[allow(non_snake_case)]
                            unsafe extern "C" fn __pymethod___richcmp____(
                                slf: *mut ::pyo3::ffi::PyObject,
                                other: *mut ::pyo3::ffi::PyObject,
                                op: ::std::os::raw::c_int,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                impl ::pyo3::impl_::pyclass::HasCustomRichCmp for PyKmer55 {}
                                ::pyo3::impl_::trampoline::richcmpfunc(
                                    slf,
                                    other,
                                    op,
                                    |py, slf, other, op| {
                                        use ::pyo3::class::basic::CompareOp;
                                        use ::pyo3::impl_::pyclass::*;
                                        let collector = PyClassImplCollector::<PyKmer55>::new();
                                        match CompareOp::from_raw(op).expect("invalid compareop") {
                                            CompareOp::Lt => collector.__lt__(py, slf, other),
                                            CompareOp::Le => collector.__le__(py, slf, other),
                                            CompareOp::Eq => collector.__eq__(py, slf, other),
                                            CompareOp::Ne => collector.__ne__(py, slf, other),
                                            CompareOp::Gt => collector.__gt__(py, slf, other),
                                            CompareOp::Ge => collector.__ge__(py, slf, other),
                                        }
                                    },
                                )
                            }
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_richcompare,
                            pfunc: <PyKmer55>::__pymethod___richcmp____
                                as ::pyo3::ffi::richcmpfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl PyKmer55 {
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = PyKmer55::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyKmer55 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["data"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyKmer55::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "data",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<PyKmer55> = result.convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        unsafe fn __pymethod_enumerate_canonical_kmer__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer55::enumerate_canonical_kmer;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyKmer55 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "enumerate_canonical_kmer",
                positional_parameter_names: &["dna"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "dna",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_count__kmer__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer55::count__kmer;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyKmer55 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "count__kmer",
                positional_parameter_names: &["dna"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "dna",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_enumerate_kmer__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer55::enumerate_kmer;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyKmer55 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "enumerate_kmer",
                positional_parameter_names: &["dna"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "dna",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_size__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer55::size;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function();
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_add_left_nucleotid__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer55::add_left_nucleotid;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyKmer55 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "add_left_nucleotid",
                positional_parameter_names: &["n"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyKmer55,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "n",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_add_right_nucleotid__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer55::add_right_nucleotid;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyKmer55 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "add_right_nucleotid",
                positional_parameter_names: &["n"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyKmer55,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "n",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_reverse_complement__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer55::reverse_complement;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyKmer55,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_0,
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_canonical__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer55::canonical;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyKmer55,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_0,
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_is_canonical__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer55::is_canonical;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyKmer55,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_0,
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_get_data__(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = ::pyo3::impl_::callback::convert(
                py,
                PyKmer55::data(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyKmer55,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_0,
                    )?,
                ),
            );
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___hash____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_hash_t> {
            let function = PyKmer55::__hash__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let _result: ::pyo3::PyResult<::pyo3::impl_::callback::HashCallbackOutput> = ::pyo3::impl_::callback::convert(
                py,
                PyKmer55::__hash__(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyKmer55,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_0,
                    )?,
                ),
            );
            ::pyo3::impl_::callback::convert(py, _result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___repr____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer55::__repr__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyKmer55::__repr__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    PyKmer55,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___str____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer55::__str__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyKmer55::__str__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    PyKmer55,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    pub struct KmerSet55(KmerIndex<55, u128, ()>);
    #[automatically_derived]
    impl ::core::clone::Clone for KmerSet55 {
        #[inline]
        fn clone(&self) -> KmerSet55 {
            KmerSet55(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for KmerSet55 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for KmerSet55 {
        const NAME: &'static str = "KmerSet55";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <KmerSet55 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for KmerSet55 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a KmerSet55 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, KmerSet55>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut KmerSet55 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, KmerSet55>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for KmerSet55 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for KmerSet55 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<KmerSet55>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for KmerSet55 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<KmerSet55>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<KmerSet55> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerSet55 {}
    impl KmerSet55 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerSet55 {}
    impl KmerSet55 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let kmer_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let kmer = base_tuple
                                .get_item(0)?
                                .extract::<PyKmer55>()
                                .unwrap()
                                .0;
                            Ok(KmerIndexEntry::<55, u128, ()> {
                                key: kmer.into(),
                                val: (),
                            })
                        })
                });
            Ok(
                Self(
                    KmerIndex::<
                        55,
                        u128,
                        (),
                    >::build_index(
                            kmer_entry_iter.map(|e| e.unwrap()),
                            path,
                            buffer_size,
                        )
                        .unwrap(),
                ),
            )
        }
        pub fn build_dna(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
            index: u64,
            modulo: u64,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let dna_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let dna = i.extract::<PyDNA>().unwrap().0;
                            Ok(dna)
                        })
                });
            let kmer_iter = dna_entry_iter
                .map(|e| e.unwrap())
                .flat_map(|dna| {
                    let kmer_it: CanonicalKmerIterator<55, u128> = (&dna).into();
                    let kmer_it_filt = kmer_it
                        .filter(|kmer| kmer.hash() % modulo == index)
                        .map(move |kmer| KmerIndexEntry::<55, u128, ()> {
                            key: kmer,
                            val: (),
                        });
                    let kmer_vec: Vec<KmerIndexEntry<55, u128, ()>> = kmer_it_filt
                        .collect();
                    kmer_vec.into_iter()
                });
            Ok(
                Self(
                    KmerIndex::<55, u128, ()>::build_index(kmer_iter, path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __contains__(&self, kmer: PyKmer55) -> PyResult<bool> {
            match self.0.get(kmer.0.into()) {
                Ok(_) => Ok(true),
                _ => Ok(false),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(KmerIndex::<55, u128, ()>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexSetIterator55u128>> {
            let iter = IndexSetIterator55u128(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
        fn size() -> PyResult<usize> {
            Ok(55)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<KmerSet55>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<KmerSet55> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerSet55::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build_dna",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerSet55::__pymethod_build_dna__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build_dna($cls, iterator, index_path, buffer_size, index, modulo)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Static(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                    c"size",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            unsafe {
                                                ::pyo3::impl_::trampoline::noargs(
                                                    _slf,
                                                    _args,
                                                    KmerSet55::__pymethod_size__,
                                                )
                                            }
                                        }
                                        trampoline
                                    },
                                    c"size()\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_STATIC),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                KmerSet55::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> ::std::os::raw::c_int {
                            ::pyo3::impl_::trampoline::objobjproc(
                                _slf,
                                arg0,
                                KmerSet55::__pymethod___contains____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_sq_contains,
                            pfunc: trampoline as ::pyo3::ffi::objobjproc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<KmerSet55>
                                for PyClassImplCollector<KmerSet55> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    KmerSet55::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                KmerSet55::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerSet55 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerSet55::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerSet55 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_build_dna__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerSet55::build_dna;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerSet55 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build_dna",
                positional_parameter_names: &[
                    "iterator",
                    "index_path",
                    "buffer_size",
                    "index",
                    "modulo",
                ],
                positional_only_parameters: 0usize,
                required_positional_parameters: 5usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 5usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_4 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[3usize].as_deref(),
                            )
                        },
                        &mut holder_3,
                        "index",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[4usize].as_deref(),
                            )
                        },
                        &mut holder_4,
                        "modulo",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = KmerSet55::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerSet55::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerSet55,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___contains____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::std::os::raw::c_int> {
            let function = KmerSet55::__contains__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerSet55::__contains__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerSet55,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "kmer",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = KmerSet55::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerSet55 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerSet55::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<KmerSet55> = result.convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerSet55::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = KmerSet55::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<KmerSet55>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod_size__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerSet55::size;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function();
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
    }
    pub struct IndexSetIterator55u128(IndexIterator<Kmer<55, u128>, ()>);
    impl ::pyo3::types::DerefToPyAny for IndexSetIterator55u128 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexSetIterator55u128 {
        const NAME: &'static str = "IndexSetIterator55u128";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexSetIterator55u128 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexSetIterator55u128 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexSetIterator55u128 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexSetIterator55u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexSetIterator55u128 {
        type Holder = ::std::option::Option<
            ::pyo3::PyRefMut<'py, IndexSetIterator55u128>,
        >;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexSetIterator55u128 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexSetIterator55u128 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexSetIterator55u128>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexSetIterator55u128 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexSetIterator55u128,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexSetIterator55u128> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexSetIterator55u128 {}
    impl IndexSetIterator55u128 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexSetIterator55u128 {}
    impl IndexSetIterator55u128 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<PyKmer55> {
            match slf.0.next() {
                Some(index_entry) => Some(PyKmer55(index_entry.key.into())),
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexSetIterator55u128>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexSetIterator55u128> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexSetIterator55u128::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexSetIterator55u128::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexSetIterator55u128 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexSetIterator55u128::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexSetIterator55u128::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexSetIterator55u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexSetIterator55u128::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexSetIterator55u128::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexSetIterator55u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IndexIterator55u8(IndexIterator<Kmer<55, u128>, u8>);
    impl ::pyo3::types::DerefToPyAny for IndexIterator55u8 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIterator55u8 {
        const NAME: &'static str = "IndexIterator55u8";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIterator55u8 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIterator55u8 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIterator55u8 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIterator55u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIterator55u8 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIterator55u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIterator55u8 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIterator55u8 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIterator55u8>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIterator55u8 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IndexIterator55u8>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIterator55u8> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator55u8 {}
    impl IndexIterator55u8 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator55u8 {}
    impl IndexIterator55u8 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(PyKmer55, u8)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((PyKmer55(index_entry.key.into()), index_entry.val))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIterator55u8>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIterator55u8> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIterator55u8::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIterator55u8::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator55u8 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator55u8::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIterator55u8::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator55u8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator55u8::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIterator55u8::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator55u8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IndexIterator55u16(IndexIterator<Kmer<55, u128>, u16>);
    impl ::pyo3::types::DerefToPyAny for IndexIterator55u16 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIterator55u16 {
        const NAME: &'static str = "IndexIterator55u16";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIterator55u16 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIterator55u16 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIterator55u16 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIterator55u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIterator55u16 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIterator55u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIterator55u16 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIterator55u16 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIterator55u16>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIterator55u16 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IndexIterator55u16>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIterator55u16> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator55u16 {}
    impl IndexIterator55u16 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator55u16 {}
    impl IndexIterator55u16 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(PyKmer55, u16)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((PyKmer55(index_entry.key.into()), index_entry.val))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIterator55u16>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIterator55u16> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIterator55u16::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIterator55u16::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator55u16 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator55u16::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIterator55u16::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator55u16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator55u16::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIterator55u16::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator55u16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IndexIterator55u32(IndexIterator<Kmer<55, u128>, u32>);
    impl ::pyo3::types::DerefToPyAny for IndexIterator55u32 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIterator55u32 {
        const NAME: &'static str = "IndexIterator55u32";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIterator55u32 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIterator55u32 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIterator55u32 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIterator55u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIterator55u32 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIterator55u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIterator55u32 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIterator55u32 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIterator55u32>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIterator55u32 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IndexIterator55u32>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIterator55u32> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator55u32 {}
    impl IndexIterator55u32 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator55u32 {}
    impl IndexIterator55u32 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(PyKmer55, u32)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((PyKmer55(index_entry.key.into()), index_entry.val))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIterator55u32>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIterator55u32> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIterator55u32::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIterator55u32::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator55u32 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator55u32::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIterator55u32::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator55u32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator55u32::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIterator55u32::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator55u32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IndexIterator55u64(IndexIterator<Kmer<55, u128>, u64>);
    impl ::pyo3::types::DerefToPyAny for IndexIterator55u64 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIterator55u64 {
        const NAME: &'static str = "IndexIterator55u64";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIterator55u64 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIterator55u64 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIterator55u64 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIterator55u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIterator55u64 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIterator55u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIterator55u64 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIterator55u64 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIterator55u64>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIterator55u64 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IndexIterator55u64>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIterator55u64> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator55u64 {}
    impl IndexIterator55u64 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator55u64 {}
    impl IndexIterator55u64 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(PyKmer55, u64)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((PyKmer55(index_entry.key.into()), index_entry.val))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIterator55u64>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIterator55u64> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIterator55u64::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIterator55u64::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator55u64 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator55u64::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIterator55u64::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator55u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator55u64::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIterator55u64::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator55u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IndexIterator55u128(IndexIterator<Kmer<55, u128>, u128>);
    impl ::pyo3::types::DerefToPyAny for IndexIterator55u128 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIterator55u128 {
        const NAME: &'static str = "IndexIterator55u128";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIterator55u128 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIterator55u128 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIterator55u128 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIterator55u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIterator55u128 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIterator55u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIterator55u128 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIterator55u128 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIterator55u128>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIterator55u128 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIterator55u128,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIterator55u128> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator55u128 {}
    impl IndexIterator55u128 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator55u128 {}
    impl IndexIterator55u128 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(PyKmer55, u128)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((PyKmer55(index_entry.key.into()), index_entry.val))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIterator55u128>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIterator55u128> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIterator55u128::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIterator55u128::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator55u128 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator55u128::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIterator55u128::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator55u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator55u128::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIterator55u128::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator55u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct KmerIndex55u8(pub KmerIndex<55, u128, u8>);
    #[automatically_derived]
    impl ::core::clone::Clone for KmerIndex55u8 {
        #[inline]
        fn clone(&self) -> KmerIndex55u8 {
            KmerIndex55u8(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for KmerIndex55u8 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for KmerIndex55u8 {
        const NAME: &'static str = "KmerIndex55u8";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <KmerIndex55u8 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for KmerIndex55u8 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a KmerIndex55u8 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, KmerIndex55u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut KmerIndex55u8 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, KmerIndex55u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for KmerIndex55u8 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for KmerIndex55u8 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<KmerIndex55u8>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for KmerIndex55u8 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<KmerIndex55u8>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<KmerIndex55u8> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex55u8 {}
    impl KmerIndex55u8 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex55u8 {}
    impl KmerIndex55u8 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let kmer_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let kmer: PyKmer55 = base_tuple
                                .get_item(0)?
                                .extract()
                                .unwrap();
                            let val: u8 = base_tuple.get_item(1)?.extract().unwrap();
                            Ok(KmerIndexEntry::<55, u128, u8> {
                                key: kmer.0.into(),
                                val,
                            })
                        })
                });
            Ok(
                Self(
                    KmerIndex::<
                        55,
                        u128,
                        u8,
                    >::build_index(
                            kmer_entry_iter.map(|e| e.unwrap()),
                            path,
                            buffer_size,
                        )
                        .unwrap(),
                ),
            )
        }
        /// Build the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)
        pub fn build_dna(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
            index: u64,
            modulo: u64,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let dna_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let dna: PyDNA = base_tuple.get_item(0)?.extract().unwrap();
                            let val: u8 = base_tuple.get_item(0)?.extract().unwrap();
                            Ok((dna, val))
                        })
                });
            let kmer_iter = dna_entry_iter
                .map(|e| e.unwrap())
                .flat_map(|(dna, val)| {
                    let kmer_it: CanonicalKmerIterator<55, u128> = (&dna.0).into();
                    let kmer_vec: Vec<KmerIndexEntry<55, u128, u8>> = kmer_it
                        .filter(|kmer| kmer.hash() % modulo == index)
                        .map(move |kmer| KmerIndexEntry::<55, u128, u8> {
                            key: kmer,
                            val,
                        })
                        .collect();
                    kmer_vec.into_iter()
                });
            Ok(
                Self(
                    KmerIndex::<55, u128, u8>::build_index(kmer_iter, path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn intersection_index(
            &self,
            other: &KmerSet55,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(IntSetu8(self.0.join_index::<()>(other.0.clone(), path, buffer_size)))
        }
        pub fn intersection_iter(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            Ok((i.extract::<PyKmer55>().unwrap().0.into(), ()))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntSetu8(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn get_all(&self, kmer: PyKmer55) -> PyResult<Vec<u8>> {
            match self.0.get_all(kmer.0.into()) {
                Ok(iter) => Ok(iter.collect()),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, kmer: PyKmer55) -> PyResult<u8> {
            match self.0.get(kmer.0.into()) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(KmerIndex::<55, u128, u8>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIterator55u8>> {
            let iter = IndexIterator55u8(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
        fn size() -> PyResult<usize> {
            Ok(55)
        }
        pub fn join_iteru8(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer55>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u8>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu8u8(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu8(
            &self,
            other: &KmerIndex55u8,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(IntIndexu8u8(self.0.join_index::<u8>(other.0.clone(), path, buffer_size)))
        }
        pub fn join_iteru16(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer55>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u16>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu8u16(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu16(
            &self,
            other: &KmerIndex55u16,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu8u16(
                    self.0.join_index::<u16>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru32(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer55>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u32>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu8u32(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu32(
            &self,
            other: &KmerIndex55u32,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu8u32(
                    self.0.join_index::<u32>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru64(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer55>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u64>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu8u64(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu64(
            &self,
            other: &KmerIndex55u64,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu8u64(
                    self.0.join_index::<u64>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru128(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer55>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u128>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu8u128(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu128(
            &self,
            other: &KmerIndex55u128,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu8u128(
                    self.0.join_index::<u128>(other.0.clone(), path, buffer_size),
                ),
            )
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<KmerIndex55u8>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<KmerIndex55u8> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex55u8::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build_dna",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex55u8::__pymethod_build_dna__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build_dna($cls, iterator, index_path, buffer_size, index, modulo)\n--\n\nBuild the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_index",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u8::__pymethod_intersection_index__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_index($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_iter",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u8::__pymethod_intersection_iter__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_iter($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"get_all",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u8::__pymethod_get_all__,
                                        )
                                    }
                                    trampoline
                                },
                                c"get_all($self, kmer)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Static(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                    c"size",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            unsafe {
                                                ::pyo3::impl_::trampoline::noargs(
                                                    _slf,
                                                    _args,
                                                    KmerIndex55u8::__pymethod_size__,
                                                )
                                            }
                                        }
                                        trampoline
                                    },
                                    c"size()\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_STATIC),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u8::__pymethod_join_iteru8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru8($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u8::__pymethod_join_indexu8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu8($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u8::__pymethod_join_iteru16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru16($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u8::__pymethod_join_indexu16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu16($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u8::__pymethod_join_iteru32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru32($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u8::__pymethod_join_indexu32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu32($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u8::__pymethod_join_iteru64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru64($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u8::__pymethod_join_indexu64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu64($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u8::__pymethod_join_iteru128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru128($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u8::__pymethod_join_indexu128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu128($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                KmerIndex55u8::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                KmerIndex55u8::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<KmerIndex55u8>
                                for PyClassImplCollector<KmerIndex55u8> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    KmerIndex55u8::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                KmerIndex55u8::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex55u8 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u8::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_build_dna__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u8::build_dna;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build_dna",
                positional_parameter_names: &[
                    "iterator",
                    "index_path",
                    "buffer_size",
                    "index",
                    "modulo",
                ],
                positional_only_parameters: 0usize,
                required_positional_parameters: 5usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 5usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_4 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[3usize].as_deref(),
                            )
                        },
                        &mut holder_3,
                        "index",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[4usize].as_deref(),
                            )
                        },
                        &mut holder_4,
                        "modulo",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_index__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u8::intersection_index;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_index",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_iter__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u8::intersection_iter;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_iter",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_get_all__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u8::get_all;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "get_all",
                positional_parameter_names: &["kmer"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "kmer",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = KmerIndex55u8::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex55u8::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex55u8,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u8::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex55u8::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex55u8,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "kmer",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = KmerIndex55u8::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex55u8::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<KmerIndex55u8> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u8::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = KmerIndex55u8::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<KmerIndex55u8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod_size__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u8::size;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function();
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u8::join_iteru8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru8",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u8::join_indexu8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu8",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u8::join_iteru16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru16",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u8::join_indexu16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu16",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u8::join_iteru32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru32",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u8::join_indexu32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu32",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u8::join_iteru64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru64",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u8::join_indexu64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu64",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u8::join_iteru128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru128",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u8::join_indexu128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu128",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
    }
    pub struct KmerIndex55u16(pub KmerIndex<55, u128, u16>);
    #[automatically_derived]
    impl ::core::clone::Clone for KmerIndex55u16 {
        #[inline]
        fn clone(&self) -> KmerIndex55u16 {
            KmerIndex55u16(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for KmerIndex55u16 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for KmerIndex55u16 {
        const NAME: &'static str = "KmerIndex55u16";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <KmerIndex55u16 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for KmerIndex55u16 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a KmerIndex55u16 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, KmerIndex55u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut KmerIndex55u16 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, KmerIndex55u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for KmerIndex55u16 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for KmerIndex55u16 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<KmerIndex55u16>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for KmerIndex55u16 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<KmerIndex55u16>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<KmerIndex55u16> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex55u16 {}
    impl KmerIndex55u16 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex55u16 {}
    impl KmerIndex55u16 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let kmer_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let kmer: PyKmer55 = base_tuple
                                .get_item(0)?
                                .extract()
                                .unwrap();
                            let val: u16 = base_tuple.get_item(1)?.extract().unwrap();
                            Ok(KmerIndexEntry::<55, u128, u16> {
                                key: kmer.0.into(),
                                val,
                            })
                        })
                });
            Ok(
                Self(
                    KmerIndex::<
                        55,
                        u128,
                        u16,
                    >::build_index(
                            kmer_entry_iter.map(|e| e.unwrap()),
                            path,
                            buffer_size,
                        )
                        .unwrap(),
                ),
            )
        }
        /// Build the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)
        pub fn build_dna(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
            index: u64,
            modulo: u64,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let dna_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let dna: PyDNA = base_tuple.get_item(0)?.extract().unwrap();
                            let val: u16 = base_tuple.get_item(0)?.extract().unwrap();
                            Ok((dna, val))
                        })
                });
            let kmer_iter = dna_entry_iter
                .map(|e| e.unwrap())
                .flat_map(|(dna, val)| {
                    let kmer_it: CanonicalKmerIterator<55, u128> = (&dna.0).into();
                    let kmer_vec: Vec<KmerIndexEntry<55, u128, u16>> = kmer_it
                        .filter(|kmer| kmer.hash() % modulo == index)
                        .map(move |kmer| KmerIndexEntry::<55, u128, u16> {
                            key: kmer,
                            val,
                        })
                        .collect();
                    kmer_vec.into_iter()
                });
            Ok(
                Self(
                    KmerIndex::<55, u128, u16>::build_index(kmer_iter, path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn intersection_index(
            &self,
            other: &KmerSet55,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(IntSetu16(self.0.join_index::<()>(other.0.clone(), path, buffer_size)))
        }
        pub fn intersection_iter(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            Ok((i.extract::<PyKmer55>().unwrap().0.into(), ()))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntSetu16(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn get_all(&self, kmer: PyKmer55) -> PyResult<Vec<u16>> {
            match self.0.get_all(kmer.0.into()) {
                Ok(iter) => Ok(iter.collect()),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, kmer: PyKmer55) -> PyResult<u16> {
            match self.0.get(kmer.0.into()) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(KmerIndex::<55, u128, u16>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIterator55u16>> {
            let iter = IndexIterator55u16(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
        fn size() -> PyResult<usize> {
            Ok(55)
        }
        pub fn join_iteru8(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer55>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u8>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu16u8(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu8(
            &self,
            other: &KmerIndex55u8,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu16u8(
                    self.0.join_index::<u8>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru16(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer55>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u16>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu16u16(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu16(
            &self,
            other: &KmerIndex55u16,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu16u16(
                    self.0.join_index::<u16>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru32(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer55>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u32>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu16u32(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu32(
            &self,
            other: &KmerIndex55u32,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu16u32(
                    self.0.join_index::<u32>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru64(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer55>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u64>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu16u64(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu64(
            &self,
            other: &KmerIndex55u64,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu16u64(
                    self.0.join_index::<u64>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru128(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer55>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u128>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu16u128(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu128(
            &self,
            other: &KmerIndex55u128,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu16u128(
                    self.0.join_index::<u128>(other.0.clone(), path, buffer_size),
                ),
            )
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<KmerIndex55u16>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<KmerIndex55u16> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex55u16::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build_dna",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex55u16::__pymethod_build_dna__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build_dna($cls, iterator, index_path, buffer_size, index, modulo)\n--\n\nBuild the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_index",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u16::__pymethod_intersection_index__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_index($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_iter",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u16::__pymethod_intersection_iter__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_iter($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"get_all",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u16::__pymethod_get_all__,
                                        )
                                    }
                                    trampoline
                                },
                                c"get_all($self, kmer)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Static(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                    c"size",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            unsafe {
                                                ::pyo3::impl_::trampoline::noargs(
                                                    _slf,
                                                    _args,
                                                    KmerIndex55u16::__pymethod_size__,
                                                )
                                            }
                                        }
                                        trampoline
                                    },
                                    c"size()\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_STATIC),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u16::__pymethod_join_iteru8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru8($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u16::__pymethod_join_indexu8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu8($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u16::__pymethod_join_iteru16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru16($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u16::__pymethod_join_indexu16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu16($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u16::__pymethod_join_iteru32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru32($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u16::__pymethod_join_indexu32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu32($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u16::__pymethod_join_iteru64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru64($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u16::__pymethod_join_indexu64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu64($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u16::__pymethod_join_iteru128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru128($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u16::__pymethod_join_indexu128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu128($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                KmerIndex55u16::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                KmerIndex55u16::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<KmerIndex55u16>
                                for PyClassImplCollector<KmerIndex55u16> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    KmerIndex55u16::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                KmerIndex55u16::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex55u16 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u16::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_build_dna__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u16::build_dna;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build_dna",
                positional_parameter_names: &[
                    "iterator",
                    "index_path",
                    "buffer_size",
                    "index",
                    "modulo",
                ],
                positional_only_parameters: 0usize,
                required_positional_parameters: 5usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 5usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_4 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[3usize].as_deref(),
                            )
                        },
                        &mut holder_3,
                        "index",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[4usize].as_deref(),
                            )
                        },
                        &mut holder_4,
                        "modulo",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_index__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u16::intersection_index;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_index",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_iter__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u16::intersection_iter;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_iter",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_get_all__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u16::get_all;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "get_all",
                positional_parameter_names: &["kmer"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "kmer",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = KmerIndex55u16::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex55u16::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex55u16,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u16::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex55u16::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex55u16,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "kmer",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = KmerIndex55u16::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex55u16::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<KmerIndex55u16> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u16::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = KmerIndex55u16::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<KmerIndex55u16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod_size__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u16::size;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function();
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u16::join_iteru8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru8",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u16::join_indexu8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu8",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u16::join_iteru16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru16",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u16::join_indexu16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu16",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u16::join_iteru32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru32",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u16::join_indexu32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu32",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u16::join_iteru64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru64",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u16::join_indexu64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu64",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u16::join_iteru128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru128",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u16::join_indexu128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu128",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
    }
    pub struct KmerIndex55u32(pub KmerIndex<55, u128, u32>);
    #[automatically_derived]
    impl ::core::clone::Clone for KmerIndex55u32 {
        #[inline]
        fn clone(&self) -> KmerIndex55u32 {
            KmerIndex55u32(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for KmerIndex55u32 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for KmerIndex55u32 {
        const NAME: &'static str = "KmerIndex55u32";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <KmerIndex55u32 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for KmerIndex55u32 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a KmerIndex55u32 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, KmerIndex55u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut KmerIndex55u32 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, KmerIndex55u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for KmerIndex55u32 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for KmerIndex55u32 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<KmerIndex55u32>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for KmerIndex55u32 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<KmerIndex55u32>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<KmerIndex55u32> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex55u32 {}
    impl KmerIndex55u32 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex55u32 {}
    impl KmerIndex55u32 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let kmer_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let kmer: PyKmer55 = base_tuple
                                .get_item(0)?
                                .extract()
                                .unwrap();
                            let val: u32 = base_tuple.get_item(1)?.extract().unwrap();
                            Ok(KmerIndexEntry::<55, u128, u32> {
                                key: kmer.0.into(),
                                val,
                            })
                        })
                });
            Ok(
                Self(
                    KmerIndex::<
                        55,
                        u128,
                        u32,
                    >::build_index(
                            kmer_entry_iter.map(|e| e.unwrap()),
                            path,
                            buffer_size,
                        )
                        .unwrap(),
                ),
            )
        }
        /// Build the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)
        pub fn build_dna(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
            index: u64,
            modulo: u64,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let dna_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let dna: PyDNA = base_tuple.get_item(0)?.extract().unwrap();
                            let val: u32 = base_tuple.get_item(0)?.extract().unwrap();
                            Ok((dna, val))
                        })
                });
            let kmer_iter = dna_entry_iter
                .map(|e| e.unwrap())
                .flat_map(|(dna, val)| {
                    let kmer_it: CanonicalKmerIterator<55, u128> = (&dna.0).into();
                    let kmer_vec: Vec<KmerIndexEntry<55, u128, u32>> = kmer_it
                        .filter(|kmer| kmer.hash() % modulo == index)
                        .map(move |kmer| KmerIndexEntry::<55, u128, u32> {
                            key: kmer,
                            val,
                        })
                        .collect();
                    kmer_vec.into_iter()
                });
            Ok(
                Self(
                    KmerIndex::<55, u128, u32>::build_index(kmer_iter, path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn intersection_index(
            &self,
            other: &KmerSet55,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(IntSetu32(self.0.join_index::<()>(other.0.clone(), path, buffer_size)))
        }
        pub fn intersection_iter(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            Ok((i.extract::<PyKmer55>().unwrap().0.into(), ()))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntSetu32(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn get_all(&self, kmer: PyKmer55) -> PyResult<Vec<u32>> {
            match self.0.get_all(kmer.0.into()) {
                Ok(iter) => Ok(iter.collect()),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, kmer: PyKmer55) -> PyResult<u32> {
            match self.0.get(kmer.0.into()) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(KmerIndex::<55, u128, u32>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIterator55u32>> {
            let iter = IndexIterator55u32(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
        fn size() -> PyResult<usize> {
            Ok(55)
        }
        pub fn join_iteru8(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer55>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u8>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu32u8(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu8(
            &self,
            other: &KmerIndex55u8,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu32u8(
                    self.0.join_index::<u8>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru16(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer55>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u16>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu32u16(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu16(
            &self,
            other: &KmerIndex55u16,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu32u16(
                    self.0.join_index::<u16>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru32(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer55>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u32>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu32u32(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu32(
            &self,
            other: &KmerIndex55u32,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu32u32(
                    self.0.join_index::<u32>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru64(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer55>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u64>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu32u64(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu64(
            &self,
            other: &KmerIndex55u64,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu32u64(
                    self.0.join_index::<u64>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru128(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer55>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u128>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu32u128(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu128(
            &self,
            other: &KmerIndex55u128,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu32u128(
                    self.0.join_index::<u128>(other.0.clone(), path, buffer_size),
                ),
            )
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<KmerIndex55u32>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<KmerIndex55u32> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex55u32::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build_dna",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex55u32::__pymethod_build_dna__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build_dna($cls, iterator, index_path, buffer_size, index, modulo)\n--\n\nBuild the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_index",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u32::__pymethod_intersection_index__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_index($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_iter",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u32::__pymethod_intersection_iter__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_iter($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"get_all",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u32::__pymethod_get_all__,
                                        )
                                    }
                                    trampoline
                                },
                                c"get_all($self, kmer)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Static(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                    c"size",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            unsafe {
                                                ::pyo3::impl_::trampoline::noargs(
                                                    _slf,
                                                    _args,
                                                    KmerIndex55u32::__pymethod_size__,
                                                )
                                            }
                                        }
                                        trampoline
                                    },
                                    c"size()\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_STATIC),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u32::__pymethod_join_iteru8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru8($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u32::__pymethod_join_indexu8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu8($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u32::__pymethod_join_iteru16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru16($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u32::__pymethod_join_indexu16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu16($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u32::__pymethod_join_iteru32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru32($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u32::__pymethod_join_indexu32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu32($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u32::__pymethod_join_iteru64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru64($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u32::__pymethod_join_indexu64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu64($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u32::__pymethod_join_iteru128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru128($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u32::__pymethod_join_indexu128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu128($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                KmerIndex55u32::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                KmerIndex55u32::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<KmerIndex55u32>
                                for PyClassImplCollector<KmerIndex55u32> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    KmerIndex55u32::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                KmerIndex55u32::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex55u32 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u32::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_build_dna__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u32::build_dna;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build_dna",
                positional_parameter_names: &[
                    "iterator",
                    "index_path",
                    "buffer_size",
                    "index",
                    "modulo",
                ],
                positional_only_parameters: 0usize,
                required_positional_parameters: 5usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 5usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_4 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[3usize].as_deref(),
                            )
                        },
                        &mut holder_3,
                        "index",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[4usize].as_deref(),
                            )
                        },
                        &mut holder_4,
                        "modulo",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_index__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u32::intersection_index;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_index",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_iter__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u32::intersection_iter;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_iter",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_get_all__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u32::get_all;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "get_all",
                positional_parameter_names: &["kmer"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "kmer",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = KmerIndex55u32::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex55u32::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex55u32,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u32::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex55u32::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex55u32,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "kmer",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = KmerIndex55u32::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex55u32::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<KmerIndex55u32> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u32::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = KmerIndex55u32::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<KmerIndex55u32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod_size__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u32::size;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function();
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u32::join_iteru8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru8",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u32::join_indexu8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu8",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u32::join_iteru16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru16",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u32::join_indexu16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu16",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u32::join_iteru32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru32",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u32::join_indexu32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu32",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u32::join_iteru64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru64",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u32::join_indexu64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu64",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u32::join_iteru128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru128",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u32::join_indexu128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu128",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
    }
    pub struct KmerIndex55u64(pub KmerIndex<55, u128, u64>);
    #[automatically_derived]
    impl ::core::clone::Clone for KmerIndex55u64 {
        #[inline]
        fn clone(&self) -> KmerIndex55u64 {
            KmerIndex55u64(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for KmerIndex55u64 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for KmerIndex55u64 {
        const NAME: &'static str = "KmerIndex55u64";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <KmerIndex55u64 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for KmerIndex55u64 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a KmerIndex55u64 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, KmerIndex55u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut KmerIndex55u64 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, KmerIndex55u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for KmerIndex55u64 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for KmerIndex55u64 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<KmerIndex55u64>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for KmerIndex55u64 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<KmerIndex55u64>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<KmerIndex55u64> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex55u64 {}
    impl KmerIndex55u64 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex55u64 {}
    impl KmerIndex55u64 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let kmer_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let kmer: PyKmer55 = base_tuple
                                .get_item(0)?
                                .extract()
                                .unwrap();
                            let val: u64 = base_tuple.get_item(1)?.extract().unwrap();
                            Ok(KmerIndexEntry::<55, u128, u64> {
                                key: kmer.0.into(),
                                val,
                            })
                        })
                });
            Ok(
                Self(
                    KmerIndex::<
                        55,
                        u128,
                        u64,
                    >::build_index(
                            kmer_entry_iter.map(|e| e.unwrap()),
                            path,
                            buffer_size,
                        )
                        .unwrap(),
                ),
            )
        }
        /// Build the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)
        pub fn build_dna(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
            index: u64,
            modulo: u64,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let dna_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let dna: PyDNA = base_tuple.get_item(0)?.extract().unwrap();
                            let val: u64 = base_tuple.get_item(0)?.extract().unwrap();
                            Ok((dna, val))
                        })
                });
            let kmer_iter = dna_entry_iter
                .map(|e| e.unwrap())
                .flat_map(|(dna, val)| {
                    let kmer_it: CanonicalKmerIterator<55, u128> = (&dna.0).into();
                    let kmer_vec: Vec<KmerIndexEntry<55, u128, u64>> = kmer_it
                        .filter(|kmer| kmer.hash() % modulo == index)
                        .map(move |kmer| KmerIndexEntry::<55, u128, u64> {
                            key: kmer,
                            val,
                        })
                        .collect();
                    kmer_vec.into_iter()
                });
            Ok(
                Self(
                    KmerIndex::<55, u128, u64>::build_index(kmer_iter, path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn intersection_index(
            &self,
            other: &KmerSet55,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(IntSetu64(self.0.join_index::<()>(other.0.clone(), path, buffer_size)))
        }
        pub fn intersection_iter(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            Ok((i.extract::<PyKmer55>().unwrap().0.into(), ()))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntSetu64(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn get_all(&self, kmer: PyKmer55) -> PyResult<Vec<u64>> {
            match self.0.get_all(kmer.0.into()) {
                Ok(iter) => Ok(iter.collect()),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, kmer: PyKmer55) -> PyResult<u64> {
            match self.0.get(kmer.0.into()) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(KmerIndex::<55, u128, u64>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIterator55u64>> {
            let iter = IndexIterator55u64(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
        fn size() -> PyResult<usize> {
            Ok(55)
        }
        pub fn join_iteru8(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer55>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u8>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu64u8(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu8(
            &self,
            other: &KmerIndex55u8,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu64u8(
                    self.0.join_index::<u8>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru16(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer55>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u16>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu64u16(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu16(
            &self,
            other: &KmerIndex55u16,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu64u16(
                    self.0.join_index::<u16>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru32(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer55>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u32>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu64u32(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu32(
            &self,
            other: &KmerIndex55u32,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu64u32(
                    self.0.join_index::<u32>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru64(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer55>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u64>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu64u64(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu64(
            &self,
            other: &KmerIndex55u64,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu64u64(
                    self.0.join_index::<u64>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru128(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer55>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u128>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu64u128(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu128(
            &self,
            other: &KmerIndex55u128,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu64u128(
                    self.0.join_index::<u128>(other.0.clone(), path, buffer_size),
                ),
            )
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<KmerIndex55u64>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<KmerIndex55u64> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex55u64::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build_dna",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex55u64::__pymethod_build_dna__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build_dna($cls, iterator, index_path, buffer_size, index, modulo)\n--\n\nBuild the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_index",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u64::__pymethod_intersection_index__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_index($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_iter",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u64::__pymethod_intersection_iter__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_iter($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"get_all",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u64::__pymethod_get_all__,
                                        )
                                    }
                                    trampoline
                                },
                                c"get_all($self, kmer)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Static(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                    c"size",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            unsafe {
                                                ::pyo3::impl_::trampoline::noargs(
                                                    _slf,
                                                    _args,
                                                    KmerIndex55u64::__pymethod_size__,
                                                )
                                            }
                                        }
                                        trampoline
                                    },
                                    c"size()\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_STATIC),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u64::__pymethod_join_iteru8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru8($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u64::__pymethod_join_indexu8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu8($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u64::__pymethod_join_iteru16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru16($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u64::__pymethod_join_indexu16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu16($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u64::__pymethod_join_iteru32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru32($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u64::__pymethod_join_indexu32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu32($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u64::__pymethod_join_iteru64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru64($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u64::__pymethod_join_indexu64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu64($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u64::__pymethod_join_iteru128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru128($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u64::__pymethod_join_indexu128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu128($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                KmerIndex55u64::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                KmerIndex55u64::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<KmerIndex55u64>
                                for PyClassImplCollector<KmerIndex55u64> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    KmerIndex55u64::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                KmerIndex55u64::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex55u64 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u64::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_build_dna__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u64::build_dna;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build_dna",
                positional_parameter_names: &[
                    "iterator",
                    "index_path",
                    "buffer_size",
                    "index",
                    "modulo",
                ],
                positional_only_parameters: 0usize,
                required_positional_parameters: 5usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 5usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_4 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[3usize].as_deref(),
                            )
                        },
                        &mut holder_3,
                        "index",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[4usize].as_deref(),
                            )
                        },
                        &mut holder_4,
                        "modulo",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_index__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u64::intersection_index;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_index",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_iter__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u64::intersection_iter;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_iter",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_get_all__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u64::get_all;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "get_all",
                positional_parameter_names: &["kmer"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "kmer",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = KmerIndex55u64::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex55u64::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex55u64,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u64::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex55u64::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex55u64,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "kmer",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = KmerIndex55u64::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex55u64::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<KmerIndex55u64> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u64::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = KmerIndex55u64::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<KmerIndex55u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod_size__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u64::size;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function();
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u64::join_iteru8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru8",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u64::join_indexu8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu8",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u64::join_iteru16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru16",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u64::join_indexu16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu16",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u64::join_iteru32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru32",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u64::join_indexu32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu32",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u64::join_iteru64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru64",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u64::join_indexu64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu64",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u64::join_iteru128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru128",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u64::join_indexu128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu128",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
    }
    pub struct KmerIndex55u128(pub KmerIndex<55, u128, u128>);
    #[automatically_derived]
    impl ::core::clone::Clone for KmerIndex55u128 {
        #[inline]
        fn clone(&self) -> KmerIndex55u128 {
            KmerIndex55u128(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for KmerIndex55u128 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for KmerIndex55u128 {
        const NAME: &'static str = "KmerIndex55u128";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <KmerIndex55u128 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for KmerIndex55u128 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a KmerIndex55u128 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, KmerIndex55u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut KmerIndex55u128 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, KmerIndex55u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for KmerIndex55u128 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for KmerIndex55u128 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<KmerIndex55u128>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for KmerIndex55u128 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<KmerIndex55u128>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<KmerIndex55u128> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex55u128 {}
    impl KmerIndex55u128 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex55u128 {}
    impl KmerIndex55u128 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let kmer_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let kmer: PyKmer55 = base_tuple
                                .get_item(0)?
                                .extract()
                                .unwrap();
                            let val: u128 = base_tuple.get_item(1)?.extract().unwrap();
                            Ok(KmerIndexEntry::<55, u128, u128> {
                                key: kmer.0.into(),
                                val,
                            })
                        })
                });
            Ok(
                Self(
                    KmerIndex::<
                        55,
                        u128,
                        u128,
                    >::build_index(
                            kmer_entry_iter.map(|e| e.unwrap()),
                            path,
                            buffer_size,
                        )
                        .unwrap(),
                ),
            )
        }
        /// Build the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)
        pub fn build_dna(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
            index: u64,
            modulo: u64,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let dna_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let dna: PyDNA = base_tuple.get_item(0)?.extract().unwrap();
                            let val: u128 = base_tuple.get_item(0)?.extract().unwrap();
                            Ok((dna, val))
                        })
                });
            let kmer_iter = dna_entry_iter
                .map(|e| e.unwrap())
                .flat_map(|(dna, val)| {
                    let kmer_it: CanonicalKmerIterator<55, u128> = (&dna.0).into();
                    let kmer_vec: Vec<KmerIndexEntry<55, u128, u128>> = kmer_it
                        .filter(|kmer| kmer.hash() % modulo == index)
                        .map(move |kmer| KmerIndexEntry::<55, u128, u128> {
                            key: kmer,
                            val,
                        })
                        .collect();
                    kmer_vec.into_iter()
                });
            Ok(
                Self(
                    KmerIndex::<
                        55,
                        u128,
                        u128,
                    >::build_index(kmer_iter, path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn intersection_index(
            &self,
            other: &KmerSet55,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(IntSetu128(self.0.join_index::<()>(other.0.clone(), path, buffer_size)))
        }
        pub fn intersection_iter(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            Ok((i.extract::<PyKmer55>().unwrap().0.into(), ()))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntSetu128(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn get_all(&self, kmer: PyKmer55) -> PyResult<Vec<u128>> {
            match self.0.get_all(kmer.0.into()) {
                Ok(iter) => Ok(iter.collect()),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, kmer: PyKmer55) -> PyResult<u128> {
            match self.0.get(kmer.0.into()) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(KmerIndex::<55, u128, u128>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIterator55u128>> {
            let iter = IndexIterator55u128(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
        fn size() -> PyResult<usize> {
            Ok(55)
        }
        pub fn join_iteru8(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer55>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u8>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu128u8(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu8(
            &self,
            other: &KmerIndex55u8,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu128u8(
                    self.0.join_index::<u8>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru16(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer55>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u16>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu128u16(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu16(
            &self,
            other: &KmerIndex55u16,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu128u16(
                    self.0.join_index::<u16>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru32(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer55>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u32>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu128u32(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu32(
            &self,
            other: &KmerIndex55u32,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu128u32(
                    self.0.join_index::<u32>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru64(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer55>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u64>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu128u64(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu64(
            &self,
            other: &KmerIndex55u64,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu128u64(
                    self.0.join_index::<u64>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru128(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer55>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u128>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu128u128(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu128(
            &self,
            other: &KmerIndex55u128,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu128u128(
                    self.0.join_index::<u128>(other.0.clone(), path, buffer_size),
                ),
            )
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<KmerIndex55u128>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<KmerIndex55u128> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex55u128::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build_dna",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex55u128::__pymethod_build_dna__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build_dna($cls, iterator, index_path, buffer_size, index, modulo)\n--\n\nBuild the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_index",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u128::__pymethod_intersection_index__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_index($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_iter",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u128::__pymethod_intersection_iter__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_iter($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"get_all",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u128::__pymethod_get_all__,
                                        )
                                    }
                                    trampoline
                                },
                                c"get_all($self, kmer)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Static(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                    c"size",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            unsafe {
                                                ::pyo3::impl_::trampoline::noargs(
                                                    _slf,
                                                    _args,
                                                    KmerIndex55u128::__pymethod_size__,
                                                )
                                            }
                                        }
                                        trampoline
                                    },
                                    c"size()\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_STATIC),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u128::__pymethod_join_iteru8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru8($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u128::__pymethod_join_indexu8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu8($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u128::__pymethod_join_iteru16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru16($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u128::__pymethod_join_indexu16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu16($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u128::__pymethod_join_iteru32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru32($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u128::__pymethod_join_indexu32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu32($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u128::__pymethod_join_iteru64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru64($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u128::__pymethod_join_indexu64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu64($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u128::__pymethod_join_iteru128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru128($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex55u128::__pymethod_join_indexu128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu128($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                KmerIndex55u128::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                KmerIndex55u128::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<KmerIndex55u128>
                                for PyClassImplCollector<KmerIndex55u128> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    KmerIndex55u128::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                KmerIndex55u128::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex55u128 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u128::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_build_dna__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u128::build_dna;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build_dna",
                positional_parameter_names: &[
                    "iterator",
                    "index_path",
                    "buffer_size",
                    "index",
                    "modulo",
                ],
                positional_only_parameters: 0usize,
                required_positional_parameters: 5usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 5usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_4 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[3usize].as_deref(),
                            )
                        },
                        &mut holder_3,
                        "index",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[4usize].as_deref(),
                            )
                        },
                        &mut holder_4,
                        "modulo",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_index__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u128::intersection_index;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_index",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_iter__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u128::intersection_iter;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_iter",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_get_all__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u128::get_all;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "get_all",
                positional_parameter_names: &["kmer"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "kmer",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = KmerIndex55u128::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex55u128::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex55u128,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u128::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex55u128::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex55u128,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "kmer",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = KmerIndex55u128::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex55u128::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<KmerIndex55u128> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u128::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = KmerIndex55u128::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<KmerIndex55u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod_size__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u128::size;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function();
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u128::join_iteru8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru8",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u128::join_indexu8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu8",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u128::join_iteru16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru16",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u128::join_indexu16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu16",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u128::join_iteru32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru32",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u128::join_indexu32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu32",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u128::join_iteru64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru64",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u128::join_indexu64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu64",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u128::join_iteru128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru128",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex55u128::join_indexu128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex55u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu128",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex55u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
    }
    m.add_class::<PyKmer55>()?;
    m.add_class::<KmerSet55>()?;
    m.add_class::<KmerIndex55u8>()?;
    m.add_class::<KmerIndex55u16>()?;
    m.add_class::<KmerIndex55u32>()?;
    m.add_class::<KmerIndex55u64>()?;
    m.add_class::<KmerIndex55u128>()?;
    pub struct BytesSerial97(pub [u8; 8 * (97 / 32 + 1)]);
    #[automatically_derived]
    impl ::core::clone::Clone for BytesSerial97 {
        #[inline]
        fn clone(&self) -> BytesSerial97 {
            BytesSerial97(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for BytesSerial97 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for BytesSerial97 {
        const NAME: &'static str = "BytesSerial97";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <BytesSerial97 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for BytesSerial97 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a BytesSerial97 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, BytesSerial97>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut BytesSerial97 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, BytesSerial97>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for BytesSerial97 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for BytesSerial97 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<BytesSerial97>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for BytesSerial97 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<BytesSerial97>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<BytesSerial97> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl BytesSerial97 {}
    impl BytesSerial97 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl BytesSerial97 {}
    impl BytesSerial97 {
        const VSIZE: usize = 8 * (97 / 32 + 1);
        pub fn new(data: &Bound<'_, PyAny>) -> PyResult<Self> {
            let slice: &[u8] = data.downcast::<PyBytes>()?.extract::<&[u8]>().unwrap();
            if slice.len() != Self::VSIZE {
                return Err(
                    PyValueError::new_err(
                        ::alloc::__export::must_use({
                            let res = ::alloc::fmt::format(
                                format_args!(
                                    "Expecting {0} size got {1}",
                                    Self::VSIZE,
                                    slice.len(),
                                ),
                            );
                            res
                        }),
                    ),
                );
            }
            Ok(Self(slice.try_into().unwrap()))
        }
        fn __bytes__(slf: PyRef<Self>) -> PyResult<Bound<'_, PyBytes>> {
            Ok(PyBytes::new(slf.py(), slf.0.as_slice()))
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<BytesSerial97>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<BytesSerial97> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                c"__bytes__",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        unsafe {
                                            ::pyo3::impl_::trampoline::noargs(
                                                _slf,
                                                _args,
                                                BytesSerial97::__pymethod___bytes____,
                                            )
                                        }
                                    }
                                    trampoline
                                },
                                c"__bytes__($self)\n--\n\n",
                            ),
                        ),
                    ),
                ],
                slots: &[
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<BytesSerial97>
                                for PyClassImplCollector<BytesSerial97> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(data)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    BytesSerial97::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl BytesSerial97 {
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = BytesSerial97::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <BytesSerial97 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["data"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = BytesSerial97::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "data",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<BytesSerial97> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        unsafe fn __pymethod___bytes____<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = BytesSerial97::__bytes__;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .downcast::<BytesSerial97>()
                        .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                        .and_then(
                            #[allow(
                                unknown_lints,
                                clippy::unnecessary_fallible_conversions
                            )]
                            |bound| {
                                ::std::convert::TryFrom::try_from(bound)
                                    .map_err(::std::convert::Into::into)
                            },
                        )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
    }
    impl From<BytesSerial97> for SimdDataStore<97> {
        fn from(value: BytesSerial97) -> Self {
            unsafe {
                let ptr = value.0.as_ptr() as *const u64;
                let narray: [u64; 97 / 32 + 1] = std::slice::from_raw_parts(
                        ptr,
                        97 / 32 + 1,
                    )
                    .try_into()
                    .unwrap();
                Self(Simd::from_array(narray))
            }
        }
    }
    impl From<SimdDataStore<97>> for BytesSerial97 {
        fn from(value: SimdDataStore<97>) -> Self {
            Self([0; 8 * (97 / 32 + 1)])
        }
    }
    pub struct PyKmer97(pub PyKmer<97, SimdDataStore<97>>);
    #[automatically_derived]
    impl ::core::clone::Clone for PyKmer97 {
        #[inline]
        fn clone(&self) -> PyKmer97 {
            PyKmer97(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for PyKmer97 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for PyKmer97 {
        const NAME: &'static str = "PyKmer97";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <PyKmer97 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for PyKmer97 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a PyKmer97 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, PyKmer97>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut PyKmer97 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, PyKmer97>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for PyKmer97 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for PyKmer97 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<PyKmer97>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for PyKmer97 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<PyKmer97>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<PyKmer97> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl PyKmer97 {}
    impl PyKmer97 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl PyKmer97 {}
    impl PyKmer97 {
        pub fn new(data: BytesSerial97) -> PyResult<Self> {
            Ok(
                Self(
                    PyKmer::<
                        97,
                        SimdDataStore<97>,
                    >(Kmer::<97, SimdDataStore<97>>(data.into())),
                ),
            )
        }
        pub fn enumerate_canonical_kmer(
            _: &Bound<'_, PyType>,
            dna: PyDNA,
        ) -> PyResult<Vec<Self>> {
            let it: CanonicalKmerIterator<97, SimdDataStore<97>> = (&(dna.0))
                .try_into()
                .unwrap();
            Ok(it.map(|u| Self(u.into())).collect())
        }
        pub fn count__kmer(_: &Bound<'_, PyType>, dna: PyDNA) -> PyResult<usize> {
            let it: KmerIterator<97, SimdDataStore<97>> = (&(dna.0)).try_into().unwrap();
            Ok(it.count())
        }
        pub fn enumerate_kmer(_: &Bound<'_, PyType>, dna: PyDNA) -> PyResult<Vec<Self>> {
            let it: KmerIterator<97, SimdDataStore<97>> = (&(dna.0)).try_into().unwrap();
            Ok(it.map(|u| Self(u.into())).collect())
        }
        pub fn size() -> PyResult<usize> {
            Ok(97)
        }
        pub fn add_left_nucleotid(&self, n: PyNucleotid) -> PyResult<Self> {
            Ok(Self(self.0.0.append_left(n.0).into()))
        }
        pub fn add_right_nucleotid(&self, n: PyNucleotid) -> PyResult<Self> {
            Ok(Self(self.0.0.append(n.0).into()))
        }
        pub fn reverse_complement(&self) -> PyResult<Self> {
            Ok(Self(self.0.0.rc().into()))
        }
        pub fn canonical(&self) -> PyResult<Self> {
            Ok(Self(self.0.0.normalize().into()))
        }
        pub fn is_canonical(&self) -> PyResult<bool> {
            Ok(self.0.0 == self.0.0.normalize())
        }
        pub fn data(&self) -> PyResult<BytesSerial97> {
            Ok(self.0.0.get_data().into())
        }
        pub fn __hash__(&self) -> PyResult<u64> {
            Ok(self.0.0.hash())
        }
        pub fn __repr__(&self) -> PyResult<String> {
            Ok(
                ::alloc::__export::must_use({
                    let res = ::alloc::fmt::format(format_args!("{0}", &self.0.0));
                    res
                }),
            )
        }
        pub fn __str__(&self) -> PyResult<String> {
            Ok((&self.0.0).into())
        }
        pub fn __lt__(&self, other: Self) -> PyResult<bool> {
            Ok(self.0.0 <= other.0.0)
        }
        pub fn __gt__(&self, other: Self) -> PyResult<bool> {
            Ok(self.0.0 >= other.0.0)
        }
        pub fn __eq__(&self, other: Self) -> PyResult<bool> {
            Ok(self.0.0 == other.0.0)
        }
    }
    impl PyKmer97 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___lt____(
            py: ::pyo3::Python,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyKmer97::__lt__(
                match ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    PyKmer97,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                ) {
                    ::std::result::Result::Ok(value) => value,
                    ::std::result::Result::Err(_) => {
                        return ::pyo3::impl_::callback::convert(py, py.NotImplemented());
                    }
                },
                match ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "other",
                ) {
                    ::std::result::Result::Ok(value) => value,
                    ::std::result::Result::Err(_) => {
                        return ::pyo3::impl_::callback::convert(py, py.NotImplemented());
                    }
                },
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    impl ::pyo3::impl_::pyclass::PyClass__lt__SlotFragment<PyKmer97>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<PyKmer97> {
        #[inline]
        unsafe fn __lt__(
            self,
            py: ::pyo3::Python,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            PyKmer97::__pymethod___lt____(py, _raw_slf, arg0)
        }
    }
    impl PyKmer97 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___gt____(
            py: ::pyo3::Python,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyKmer97::__gt__(
                match ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    PyKmer97,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                ) {
                    ::std::result::Result::Ok(value) => value,
                    ::std::result::Result::Err(_) => {
                        return ::pyo3::impl_::callback::convert(py, py.NotImplemented());
                    }
                },
                match ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "other",
                ) {
                    ::std::result::Result::Ok(value) => value,
                    ::std::result::Result::Err(_) => {
                        return ::pyo3::impl_::callback::convert(py, py.NotImplemented());
                    }
                },
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    impl ::pyo3::impl_::pyclass::PyClass__gt__SlotFragment<PyKmer97>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<PyKmer97> {
        #[inline]
        unsafe fn __gt__(
            self,
            py: ::pyo3::Python,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            PyKmer97::__pymethod___gt____(py, _raw_slf, arg0)
        }
    }
    impl PyKmer97 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___eq____(
            py: ::pyo3::Python,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyKmer97::__eq__(
                match ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    PyKmer97,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                ) {
                    ::std::result::Result::Ok(value) => value,
                    ::std::result::Result::Err(_) => {
                        return ::pyo3::impl_::callback::convert(py, py.NotImplemented());
                    }
                },
                match ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "other",
                ) {
                    ::std::result::Result::Ok(value) => value,
                    ::std::result::Result::Err(_) => {
                        return ::pyo3::impl_::callback::convert(py, py.NotImplemented());
                    }
                },
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    impl ::pyo3::impl_::pyclass::PyClass__eq__SlotFragment<PyKmer97>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<PyKmer97> {
        #[inline]
        unsafe fn __eq__(
            self,
            py: ::pyo3::Python,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            PyKmer97::__pymethod___eq____(py, _raw_slf, arg0)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<PyKmer97>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<PyKmer97> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"enumerate_canonical_kmer",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                PyKmer97::__pymethod_enumerate_canonical_kmer__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"enumerate_canonical_kmer($cls, dna)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"count__kmer",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                PyKmer97::__pymethod_count__kmer__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"count__kmer($cls, dna)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"enumerate_kmer",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                PyKmer97::__pymethod_enumerate_kmer__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"enumerate_kmer($cls, dna)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Static(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                    c"size",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            unsafe {
                                                ::pyo3::impl_::trampoline::noargs(
                                                    _slf,
                                                    _args,
                                                    PyKmer97::__pymethod_size__,
                                                )
                                            }
                                        }
                                        trampoline
                                    },
                                    c"size()\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_STATIC),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"add_left_nucleotid",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            PyKmer97::__pymethod_add_left_nucleotid__,
                                        )
                                    }
                                    trampoline
                                },
                                c"add_left_nucleotid($self, n)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"add_right_nucleotid",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            PyKmer97::__pymethod_add_right_nucleotid__,
                                        )
                                    }
                                    trampoline
                                },
                                c"add_right_nucleotid($self, n)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                c"reverse_complement",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        unsafe {
                                            ::pyo3::impl_::trampoline::noargs(
                                                _slf,
                                                _args,
                                                PyKmer97::__pymethod_reverse_complement__,
                                            )
                                        }
                                    }
                                    trampoline
                                },
                                c"reverse_complement($self)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                c"canonical",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        unsafe {
                                            ::pyo3::impl_::trampoline::noargs(
                                                _slf,
                                                _args,
                                                PyKmer97::__pymethod_canonical__,
                                            )
                                        }
                                    }
                                    trampoline
                                },
                                c"canonical($self)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                c"is_canonical",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        unsafe {
                                            ::pyo3::impl_::trampoline::noargs(
                                                _slf,
                                                _args,
                                                PyKmer97::__pymethod_is_canonical__,
                                            )
                                        }
                                    }
                                    trampoline
                                },
                                c"is_canonical($self)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Getter(
                            ::pyo3::impl_::pymethods::PyGetterDef::new(
                                c"data",
                                PyKmer97::__pymethod_get_data__,
                                c"",
                            ),
                        ),
                    ),
                ],
                slots: &[
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<PyKmer97>
                                for PyClassImplCollector<PyKmer97> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(data)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    PyKmer97::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_hash_t {
                            ::pyo3::impl_::trampoline::hashfunc(
                                _slf,
                                PyKmer97::__pymethod___hash____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_hash,
                            pfunc: trampoline as ::pyo3::ffi::hashfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::reprfunc(
                                _slf,
                                PyKmer97::__pymethod___repr____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_repr,
                            pfunc: trampoline as ::pyo3::ffi::reprfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::reprfunc(
                                _slf,
                                PyKmer97::__pymethod___str____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_str,
                            pfunc: trampoline as ::pyo3::ffi::reprfunc as _,
                        }
                    },
                    {
                        #[allow(unknown_lints, non_local_definitions)]
                        impl PyKmer97 {
                            #[allow(non_snake_case)]
                            unsafe extern "C" fn __pymethod___richcmp____(
                                slf: *mut ::pyo3::ffi::PyObject,
                                other: *mut ::pyo3::ffi::PyObject,
                                op: ::std::os::raw::c_int,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                impl ::pyo3::impl_::pyclass::HasCustomRichCmp for PyKmer97 {}
                                ::pyo3::impl_::trampoline::richcmpfunc(
                                    slf,
                                    other,
                                    op,
                                    |py, slf, other, op| {
                                        use ::pyo3::class::basic::CompareOp;
                                        use ::pyo3::impl_::pyclass::*;
                                        let collector = PyClassImplCollector::<PyKmer97>::new();
                                        match CompareOp::from_raw(op).expect("invalid compareop") {
                                            CompareOp::Lt => collector.__lt__(py, slf, other),
                                            CompareOp::Le => collector.__le__(py, slf, other),
                                            CompareOp::Eq => collector.__eq__(py, slf, other),
                                            CompareOp::Ne => collector.__ne__(py, slf, other),
                                            CompareOp::Gt => collector.__gt__(py, slf, other),
                                            CompareOp::Ge => collector.__ge__(py, slf, other),
                                        }
                                    },
                                )
                            }
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_richcompare,
                            pfunc: <PyKmer97>::__pymethod___richcmp____
                                as ::pyo3::ffi::richcmpfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl PyKmer97 {
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = PyKmer97::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyKmer97 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["data"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyKmer97::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "data",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<PyKmer97> = result.convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        unsafe fn __pymethod_enumerate_canonical_kmer__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer97::enumerate_canonical_kmer;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyKmer97 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "enumerate_canonical_kmer",
                positional_parameter_names: &["dna"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "dna",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_count__kmer__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer97::count__kmer;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyKmer97 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "count__kmer",
                positional_parameter_names: &["dna"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "dna",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_enumerate_kmer__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer97::enumerate_kmer;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyKmer97 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "enumerate_kmer",
                positional_parameter_names: &["dna"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "dna",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_size__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer97::size;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function();
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_add_left_nucleotid__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer97::add_left_nucleotid;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyKmer97 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "add_left_nucleotid",
                positional_parameter_names: &["n"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyKmer97,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "n",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_add_right_nucleotid__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer97::add_right_nucleotid;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyKmer97 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "add_right_nucleotid",
                positional_parameter_names: &["n"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyKmer97,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "n",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_reverse_complement__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer97::reverse_complement;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyKmer97,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_0,
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_canonical__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer97::canonical;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyKmer97,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_0,
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_is_canonical__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer97::is_canonical;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyKmer97,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_0,
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_get_data__(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = ::pyo3::impl_::callback::convert(
                py,
                PyKmer97::data(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyKmer97,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_0,
                    )?,
                ),
            );
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___hash____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_hash_t> {
            let function = PyKmer97::__hash__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let _result: ::pyo3::PyResult<::pyo3::impl_::callback::HashCallbackOutput> = ::pyo3::impl_::callback::convert(
                py,
                PyKmer97::__hash__(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyKmer97,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_0,
                    )?,
                ),
            );
            ::pyo3::impl_::callback::convert(py, _result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___repr____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer97::__repr__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyKmer97::__repr__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    PyKmer97,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___str____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer97::__str__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyKmer97::__str__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    PyKmer97,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    type Store97 = SimdDataStore<97>;
    pub struct KmerSet97(KmerIndex<97, Store97, ()>);
    #[automatically_derived]
    impl ::core::clone::Clone for KmerSet97 {
        #[inline]
        fn clone(&self) -> KmerSet97 {
            KmerSet97(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for KmerSet97 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for KmerSet97 {
        const NAME: &'static str = "KmerSet97";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <KmerSet97 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for KmerSet97 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a KmerSet97 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, KmerSet97>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut KmerSet97 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, KmerSet97>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for KmerSet97 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for KmerSet97 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<KmerSet97>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for KmerSet97 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<KmerSet97>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<KmerSet97> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerSet97 {}
    impl KmerSet97 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerSet97 {}
    impl KmerSet97 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let kmer_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let kmer = base_tuple
                                .get_item(0)?
                                .extract::<PyKmer97>()
                                .unwrap()
                                .0;
                            Ok(KmerIndexEntry::<97, Store97, ()> {
                                key: kmer.into(),
                                val: (),
                            })
                        })
                });
            Ok(
                Self(
                    KmerIndex::<
                        97,
                        Store97,
                        (),
                    >::build_index(
                            kmer_entry_iter.map(|e| e.unwrap()),
                            path,
                            buffer_size,
                        )
                        .unwrap(),
                ),
            )
        }
        pub fn build_dna(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
            index: u64,
            modulo: u64,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let dna_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let dna = i.extract::<PyDNA>().unwrap().0;
                            Ok(dna)
                        })
                });
            let kmer_iter = dna_entry_iter
                .map(|e| e.unwrap())
                .flat_map(|dna| {
                    let kmer_it: CanonicalKmerIterator<97, Store97> = (&dna).into();
                    let kmer_it_filt = kmer_it
                        .filter(|kmer| kmer.hash() % modulo == index)
                        .map(move |kmer| KmerIndexEntry::<97, Store97, ()> {
                            key: kmer,
                            val: (),
                        });
                    let kmer_vec: Vec<KmerIndexEntry<97, Store97, ()>> = kmer_it_filt
                        .collect();
                    kmer_vec.into_iter()
                });
            Ok(
                Self(
                    KmerIndex::<
                        97,
                        Store97,
                        (),
                    >::build_index(kmer_iter, path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __contains__(&self, kmer: PyKmer97) -> PyResult<bool> {
            match self.0.get(kmer.0.into()) {
                Ok(_) => Ok(true),
                _ => Ok(false),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(KmerIndex::<97, Store97, ()>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexSetIterator97Store97>> {
            let iter = IndexSetIterator97Store97(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
        fn size() -> PyResult<usize> {
            Ok(97)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<KmerSet97>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<KmerSet97> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerSet97::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build_dna",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerSet97::__pymethod_build_dna__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build_dna($cls, iterator, index_path, buffer_size, index, modulo)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Static(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                    c"size",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            unsafe {
                                                ::pyo3::impl_::trampoline::noargs(
                                                    _slf,
                                                    _args,
                                                    KmerSet97::__pymethod_size__,
                                                )
                                            }
                                        }
                                        trampoline
                                    },
                                    c"size()\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_STATIC),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                KmerSet97::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> ::std::os::raw::c_int {
                            ::pyo3::impl_::trampoline::objobjproc(
                                _slf,
                                arg0,
                                KmerSet97::__pymethod___contains____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_sq_contains,
                            pfunc: trampoline as ::pyo3::ffi::objobjproc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<KmerSet97>
                                for PyClassImplCollector<KmerSet97> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    KmerSet97::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                KmerSet97::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerSet97 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerSet97::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerSet97 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_build_dna__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerSet97::build_dna;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerSet97 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build_dna",
                positional_parameter_names: &[
                    "iterator",
                    "index_path",
                    "buffer_size",
                    "index",
                    "modulo",
                ],
                positional_only_parameters: 0usize,
                required_positional_parameters: 5usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 5usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_4 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[3usize].as_deref(),
                            )
                        },
                        &mut holder_3,
                        "index",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[4usize].as_deref(),
                            )
                        },
                        &mut holder_4,
                        "modulo",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = KmerSet97::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerSet97::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerSet97,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___contains____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::std::os::raw::c_int> {
            let function = KmerSet97::__contains__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerSet97::__contains__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerSet97,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "kmer",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = KmerSet97::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerSet97 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerSet97::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<KmerSet97> = result.convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerSet97::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = KmerSet97::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<KmerSet97>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod_size__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerSet97::size;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function();
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
    }
    pub struct IndexSetIterator97Store97(IndexIterator<Kmer<97, Store97>, ()>);
    impl ::pyo3::types::DerefToPyAny for IndexSetIterator97Store97 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexSetIterator97Store97 {
        const NAME: &'static str = "IndexSetIterator97Store97";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexSetIterator97Store97 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexSetIterator97Store97 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexSetIterator97Store97 {
        type Holder = ::std::option::Option<
            ::pyo3::PyRef<'py, IndexSetIterator97Store97>,
        >;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexSetIterator97Store97 {
        type Holder = ::std::option::Option<
            ::pyo3::PyRefMut<'py, IndexSetIterator97Store97>,
        >;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexSetIterator97Store97 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexSetIterator97Store97 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexSetIterator97Store97>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexSetIterator97Store97 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexSetIterator97Store97,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexSetIterator97Store97> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexSetIterator97Store97 {}
    impl IndexSetIterator97Store97 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexSetIterator97Store97 {}
    impl IndexSetIterator97Store97 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<PyKmer97> {
            match slf.0.next() {
                Some(index_entry) => Some(PyKmer97(index_entry.key.into())),
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexSetIterator97Store97>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexSetIterator97Store97> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexSetIterator97Store97::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexSetIterator97Store97::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexSetIterator97Store97 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexSetIterator97Store97::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexSetIterator97Store97::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexSetIterator97Store97>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexSetIterator97Store97::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexSetIterator97Store97::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexSetIterator97Store97>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IndexIterator97u8(IndexIterator<Kmer<97, Store97>, u8>);
    impl ::pyo3::types::DerefToPyAny for IndexIterator97u8 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIterator97u8 {
        const NAME: &'static str = "IndexIterator97u8";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIterator97u8 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIterator97u8 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIterator97u8 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIterator97u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIterator97u8 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIterator97u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIterator97u8 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIterator97u8 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIterator97u8>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIterator97u8 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IndexIterator97u8>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIterator97u8> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator97u8 {}
    impl IndexIterator97u8 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator97u8 {}
    impl IndexIterator97u8 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(PyKmer97, u8)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((PyKmer97(index_entry.key.into()), index_entry.val))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIterator97u8>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIterator97u8> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIterator97u8::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIterator97u8::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator97u8 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator97u8::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIterator97u8::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator97u8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator97u8::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIterator97u8::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator97u8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IndexIterator97u16(IndexIterator<Kmer<97, Store97>, u16>);
    impl ::pyo3::types::DerefToPyAny for IndexIterator97u16 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIterator97u16 {
        const NAME: &'static str = "IndexIterator97u16";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIterator97u16 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIterator97u16 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIterator97u16 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIterator97u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIterator97u16 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIterator97u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIterator97u16 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIterator97u16 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIterator97u16>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIterator97u16 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IndexIterator97u16>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIterator97u16> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator97u16 {}
    impl IndexIterator97u16 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator97u16 {}
    impl IndexIterator97u16 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(PyKmer97, u16)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((PyKmer97(index_entry.key.into()), index_entry.val))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIterator97u16>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIterator97u16> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIterator97u16::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIterator97u16::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator97u16 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator97u16::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIterator97u16::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator97u16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator97u16::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIterator97u16::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator97u16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IndexIterator97u32(IndexIterator<Kmer<97, Store97>, u32>);
    impl ::pyo3::types::DerefToPyAny for IndexIterator97u32 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIterator97u32 {
        const NAME: &'static str = "IndexIterator97u32";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIterator97u32 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIterator97u32 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIterator97u32 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIterator97u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIterator97u32 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIterator97u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIterator97u32 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIterator97u32 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIterator97u32>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIterator97u32 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IndexIterator97u32>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIterator97u32> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator97u32 {}
    impl IndexIterator97u32 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator97u32 {}
    impl IndexIterator97u32 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(PyKmer97, u32)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((PyKmer97(index_entry.key.into()), index_entry.val))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIterator97u32>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIterator97u32> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIterator97u32::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIterator97u32::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator97u32 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator97u32::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIterator97u32::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator97u32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator97u32::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIterator97u32::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator97u32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IndexIterator97u64(IndexIterator<Kmer<97, Store97>, u64>);
    impl ::pyo3::types::DerefToPyAny for IndexIterator97u64 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIterator97u64 {
        const NAME: &'static str = "IndexIterator97u64";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIterator97u64 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIterator97u64 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIterator97u64 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIterator97u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIterator97u64 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIterator97u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIterator97u64 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIterator97u64 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIterator97u64>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIterator97u64 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<IndexIterator97u64>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIterator97u64> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator97u64 {}
    impl IndexIterator97u64 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator97u64 {}
    impl IndexIterator97u64 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(PyKmer97, u64)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((PyKmer97(index_entry.key.into()), index_entry.val))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIterator97u64>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIterator97u64> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIterator97u64::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIterator97u64::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator97u64 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator97u64::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIterator97u64::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator97u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator97u64::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIterator97u64::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator97u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IndexIterator97u128(IndexIterator<Kmer<97, Store97>, u128>);
    impl ::pyo3::types::DerefToPyAny for IndexIterator97u128 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIterator97u128 {
        const NAME: &'static str = "IndexIterator97u128";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIterator97u128 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIterator97u128 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIterator97u128 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIterator97u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIterator97u128 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIterator97u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIterator97u128 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIterator97u128 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIterator97u128>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIterator97u128 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIterator97u128,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIterator97u128> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator97u128 {}
    impl IndexIterator97u128 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator97u128 {}
    impl IndexIterator97u128 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(PyKmer97, u128)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((PyKmer97(index_entry.key.into()), index_entry.val))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIterator97u128>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIterator97u128> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIterator97u128::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIterator97u128::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator97u128 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator97u128::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIterator97u128::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator97u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator97u128::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIterator97u128::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator97u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct KmerIndex97u8(pub KmerIndex<97, Store97, u8>);
    #[automatically_derived]
    impl ::core::clone::Clone for KmerIndex97u8 {
        #[inline]
        fn clone(&self) -> KmerIndex97u8 {
            KmerIndex97u8(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for KmerIndex97u8 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for KmerIndex97u8 {
        const NAME: &'static str = "KmerIndex97u8";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <KmerIndex97u8 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for KmerIndex97u8 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a KmerIndex97u8 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, KmerIndex97u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut KmerIndex97u8 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, KmerIndex97u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for KmerIndex97u8 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for KmerIndex97u8 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<KmerIndex97u8>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for KmerIndex97u8 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<KmerIndex97u8>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<KmerIndex97u8> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex97u8 {}
    impl KmerIndex97u8 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex97u8 {}
    impl KmerIndex97u8 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let kmer_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let kmer: PyKmer97 = base_tuple
                                .get_item(0)?
                                .extract()
                                .unwrap();
                            let val: u8 = base_tuple.get_item(1)?.extract().unwrap();
                            Ok(KmerIndexEntry::<97, Store97, u8> {
                                key: kmer.0.into(),
                                val,
                            })
                        })
                });
            Ok(
                Self(
                    KmerIndex::<
                        97,
                        Store97,
                        u8,
                    >::build_index(
                            kmer_entry_iter.map(|e| e.unwrap()),
                            path,
                            buffer_size,
                        )
                        .unwrap(),
                ),
            )
        }
        /// Build the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)
        pub fn build_dna(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
            index: u64,
            modulo: u64,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let dna_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let dna: PyDNA = base_tuple.get_item(0)?.extract().unwrap();
                            let val: u8 = base_tuple.get_item(0)?.extract().unwrap();
                            Ok((dna, val))
                        })
                });
            let kmer_iter = dna_entry_iter
                .map(|e| e.unwrap())
                .flat_map(|(dna, val)| {
                    let kmer_it: CanonicalKmerIterator<97, Store97> = (&dna.0).into();
                    let kmer_vec: Vec<KmerIndexEntry<97, Store97, u8>> = kmer_it
                        .filter(|kmer| kmer.hash() % modulo == index)
                        .map(move |kmer| KmerIndexEntry::<97, Store97, u8> {
                            key: kmer,
                            val,
                        })
                        .collect();
                    kmer_vec.into_iter()
                });
            Ok(
                Self(
                    KmerIndex::<
                        97,
                        Store97,
                        u8,
                    >::build_index(kmer_iter, path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn intersection_index(
            &self,
            other: &KmerSet97,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(IntSetu8(self.0.join_index::<()>(other.0.clone(), path, buffer_size)))
        }
        pub fn intersection_iter(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            Ok((i.extract::<PyKmer97>().unwrap().0.into(), ()))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntSetu8(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn get_all(&self, kmer: PyKmer97) -> PyResult<Vec<u8>> {
            match self.0.get_all(kmer.0.into()) {
                Ok(iter) => Ok(iter.collect()),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, kmer: PyKmer97) -> PyResult<u8> {
            match self.0.get(kmer.0.into()) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(KmerIndex::<97, Store97, u8>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIterator97u8>> {
            let iter = IndexIterator97u8(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
        fn size() -> PyResult<usize> {
            Ok(97)
        }
        pub fn join_iteru8(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer97>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u8>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu8u8(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu8(
            &self,
            other: &KmerIndex97u8,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(IntIndexu8u8(self.0.join_index::<u8>(other.0.clone(), path, buffer_size)))
        }
        pub fn join_iteru16(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer97>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u16>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu8u16(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu16(
            &self,
            other: &KmerIndex97u16,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu8u16(
                    self.0.join_index::<u16>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru32(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer97>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u32>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu8u32(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu32(
            &self,
            other: &KmerIndex97u32,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu8u32(
                    self.0.join_index::<u32>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru64(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer97>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u64>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu8u64(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu64(
            &self,
            other: &KmerIndex97u64,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu8u64(
                    self.0.join_index::<u64>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru128(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer97>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u128>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu8u128(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu128(
            &self,
            other: &KmerIndex97u128,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu8u128(
                    self.0.join_index::<u128>(other.0.clone(), path, buffer_size),
                ),
            )
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<KmerIndex97u8>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<KmerIndex97u8> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex97u8::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build_dna",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex97u8::__pymethod_build_dna__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build_dna($cls, iterator, index_path, buffer_size, index, modulo)\n--\n\nBuild the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_index",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u8::__pymethod_intersection_index__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_index($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_iter",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u8::__pymethod_intersection_iter__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_iter($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"get_all",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u8::__pymethod_get_all__,
                                        )
                                    }
                                    trampoline
                                },
                                c"get_all($self, kmer)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Static(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                    c"size",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            unsafe {
                                                ::pyo3::impl_::trampoline::noargs(
                                                    _slf,
                                                    _args,
                                                    KmerIndex97u8::__pymethod_size__,
                                                )
                                            }
                                        }
                                        trampoline
                                    },
                                    c"size()\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_STATIC),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u8::__pymethod_join_iteru8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru8($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u8::__pymethod_join_indexu8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu8($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u8::__pymethod_join_iteru16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru16($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u8::__pymethod_join_indexu16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu16($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u8::__pymethod_join_iteru32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru32($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u8::__pymethod_join_indexu32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu32($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u8::__pymethod_join_iteru64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru64($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u8::__pymethod_join_indexu64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu64($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u8::__pymethod_join_iteru128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru128($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u8::__pymethod_join_indexu128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu128($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                KmerIndex97u8::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                KmerIndex97u8::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<KmerIndex97u8>
                                for PyClassImplCollector<KmerIndex97u8> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    KmerIndex97u8::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                KmerIndex97u8::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex97u8 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u8::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_build_dna__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u8::build_dna;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build_dna",
                positional_parameter_names: &[
                    "iterator",
                    "index_path",
                    "buffer_size",
                    "index",
                    "modulo",
                ],
                positional_only_parameters: 0usize,
                required_positional_parameters: 5usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 5usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_4 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[3usize].as_deref(),
                            )
                        },
                        &mut holder_3,
                        "index",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[4usize].as_deref(),
                            )
                        },
                        &mut holder_4,
                        "modulo",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_index__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u8::intersection_index;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_index",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_iter__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u8::intersection_iter;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_iter",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_get_all__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u8::get_all;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "get_all",
                positional_parameter_names: &["kmer"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "kmer",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = KmerIndex97u8::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex97u8::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex97u8,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u8::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex97u8::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex97u8,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "kmer",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = KmerIndex97u8::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex97u8::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<KmerIndex97u8> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u8::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = KmerIndex97u8::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<KmerIndex97u8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod_size__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u8::size;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function();
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u8::join_iteru8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru8",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u8::join_indexu8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu8",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u8::join_iteru16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru16",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u8::join_indexu16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu16",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u8::join_iteru32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru32",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u8::join_indexu32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu32",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u8::join_iteru64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru64",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u8::join_indexu64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu64",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u8::join_iteru128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru128",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u8::join_indexu128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu128",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
    }
    pub struct KmerIndex97u16(pub KmerIndex<97, Store97, u16>);
    #[automatically_derived]
    impl ::core::clone::Clone for KmerIndex97u16 {
        #[inline]
        fn clone(&self) -> KmerIndex97u16 {
            KmerIndex97u16(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for KmerIndex97u16 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for KmerIndex97u16 {
        const NAME: &'static str = "KmerIndex97u16";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <KmerIndex97u16 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for KmerIndex97u16 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a KmerIndex97u16 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, KmerIndex97u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut KmerIndex97u16 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, KmerIndex97u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for KmerIndex97u16 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for KmerIndex97u16 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<KmerIndex97u16>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for KmerIndex97u16 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<KmerIndex97u16>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<KmerIndex97u16> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex97u16 {}
    impl KmerIndex97u16 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex97u16 {}
    impl KmerIndex97u16 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let kmer_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let kmer: PyKmer97 = base_tuple
                                .get_item(0)?
                                .extract()
                                .unwrap();
                            let val: u16 = base_tuple.get_item(1)?.extract().unwrap();
                            Ok(KmerIndexEntry::<97, Store97, u16> {
                                key: kmer.0.into(),
                                val,
                            })
                        })
                });
            Ok(
                Self(
                    KmerIndex::<
                        97,
                        Store97,
                        u16,
                    >::build_index(
                            kmer_entry_iter.map(|e| e.unwrap()),
                            path,
                            buffer_size,
                        )
                        .unwrap(),
                ),
            )
        }
        /// Build the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)
        pub fn build_dna(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
            index: u64,
            modulo: u64,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let dna_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let dna: PyDNA = base_tuple.get_item(0)?.extract().unwrap();
                            let val: u16 = base_tuple.get_item(0)?.extract().unwrap();
                            Ok((dna, val))
                        })
                });
            let kmer_iter = dna_entry_iter
                .map(|e| e.unwrap())
                .flat_map(|(dna, val)| {
                    let kmer_it: CanonicalKmerIterator<97, Store97> = (&dna.0).into();
                    let kmer_vec: Vec<KmerIndexEntry<97, Store97, u16>> = kmer_it
                        .filter(|kmer| kmer.hash() % modulo == index)
                        .map(move |kmer| KmerIndexEntry::<97, Store97, u16> {
                            key: kmer,
                            val,
                        })
                        .collect();
                    kmer_vec.into_iter()
                });
            Ok(
                Self(
                    KmerIndex::<
                        97,
                        Store97,
                        u16,
                    >::build_index(kmer_iter, path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn intersection_index(
            &self,
            other: &KmerSet97,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(IntSetu16(self.0.join_index::<()>(other.0.clone(), path, buffer_size)))
        }
        pub fn intersection_iter(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            Ok((i.extract::<PyKmer97>().unwrap().0.into(), ()))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntSetu16(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn get_all(&self, kmer: PyKmer97) -> PyResult<Vec<u16>> {
            match self.0.get_all(kmer.0.into()) {
                Ok(iter) => Ok(iter.collect()),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, kmer: PyKmer97) -> PyResult<u16> {
            match self.0.get(kmer.0.into()) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(KmerIndex::<97, Store97, u16>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIterator97u16>> {
            let iter = IndexIterator97u16(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
        fn size() -> PyResult<usize> {
            Ok(97)
        }
        pub fn join_iteru8(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer97>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u8>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu16u8(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu8(
            &self,
            other: &KmerIndex97u8,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu16u8(
                    self.0.join_index::<u8>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru16(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer97>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u16>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu16u16(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu16(
            &self,
            other: &KmerIndex97u16,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu16u16(
                    self.0.join_index::<u16>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru32(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer97>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u32>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu16u32(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu32(
            &self,
            other: &KmerIndex97u32,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu16u32(
                    self.0.join_index::<u32>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru64(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer97>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u64>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu16u64(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu64(
            &self,
            other: &KmerIndex97u64,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu16u64(
                    self.0.join_index::<u64>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru128(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer97>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u128>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu16u128(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu128(
            &self,
            other: &KmerIndex97u128,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu16u128(
                    self.0.join_index::<u128>(other.0.clone(), path, buffer_size),
                ),
            )
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<KmerIndex97u16>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<KmerIndex97u16> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex97u16::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build_dna",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex97u16::__pymethod_build_dna__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build_dna($cls, iterator, index_path, buffer_size, index, modulo)\n--\n\nBuild the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_index",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u16::__pymethod_intersection_index__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_index($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_iter",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u16::__pymethod_intersection_iter__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_iter($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"get_all",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u16::__pymethod_get_all__,
                                        )
                                    }
                                    trampoline
                                },
                                c"get_all($self, kmer)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Static(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                    c"size",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            unsafe {
                                                ::pyo3::impl_::trampoline::noargs(
                                                    _slf,
                                                    _args,
                                                    KmerIndex97u16::__pymethod_size__,
                                                )
                                            }
                                        }
                                        trampoline
                                    },
                                    c"size()\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_STATIC),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u16::__pymethod_join_iteru8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru8($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u16::__pymethod_join_indexu8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu8($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u16::__pymethod_join_iteru16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru16($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u16::__pymethod_join_indexu16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu16($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u16::__pymethod_join_iteru32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru32($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u16::__pymethod_join_indexu32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu32($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u16::__pymethod_join_iteru64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru64($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u16::__pymethod_join_indexu64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu64($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u16::__pymethod_join_iteru128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru128($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u16::__pymethod_join_indexu128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu128($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                KmerIndex97u16::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                KmerIndex97u16::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<KmerIndex97u16>
                                for PyClassImplCollector<KmerIndex97u16> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    KmerIndex97u16::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                KmerIndex97u16::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex97u16 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u16::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_build_dna__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u16::build_dna;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build_dna",
                positional_parameter_names: &[
                    "iterator",
                    "index_path",
                    "buffer_size",
                    "index",
                    "modulo",
                ],
                positional_only_parameters: 0usize,
                required_positional_parameters: 5usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 5usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_4 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[3usize].as_deref(),
                            )
                        },
                        &mut holder_3,
                        "index",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[4usize].as_deref(),
                            )
                        },
                        &mut holder_4,
                        "modulo",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_index__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u16::intersection_index;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_index",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_iter__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u16::intersection_iter;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_iter",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_get_all__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u16::get_all;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "get_all",
                positional_parameter_names: &["kmer"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "kmer",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = KmerIndex97u16::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex97u16::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex97u16,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u16::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex97u16::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex97u16,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "kmer",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = KmerIndex97u16::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex97u16::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<KmerIndex97u16> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u16::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = KmerIndex97u16::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<KmerIndex97u16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod_size__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u16::size;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function();
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u16::join_iteru8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru8",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u16::join_indexu8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu8",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u16::join_iteru16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru16",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u16::join_indexu16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu16",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u16::join_iteru32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru32",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u16::join_indexu32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu32",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u16::join_iteru64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru64",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u16::join_indexu64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu64",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u16::join_iteru128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru128",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u16::join_indexu128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu128",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
    }
    pub struct KmerIndex97u32(pub KmerIndex<97, Store97, u32>);
    #[automatically_derived]
    impl ::core::clone::Clone for KmerIndex97u32 {
        #[inline]
        fn clone(&self) -> KmerIndex97u32 {
            KmerIndex97u32(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for KmerIndex97u32 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for KmerIndex97u32 {
        const NAME: &'static str = "KmerIndex97u32";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <KmerIndex97u32 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for KmerIndex97u32 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a KmerIndex97u32 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, KmerIndex97u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut KmerIndex97u32 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, KmerIndex97u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for KmerIndex97u32 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for KmerIndex97u32 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<KmerIndex97u32>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for KmerIndex97u32 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<KmerIndex97u32>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<KmerIndex97u32> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex97u32 {}
    impl KmerIndex97u32 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex97u32 {}
    impl KmerIndex97u32 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let kmer_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let kmer: PyKmer97 = base_tuple
                                .get_item(0)?
                                .extract()
                                .unwrap();
                            let val: u32 = base_tuple.get_item(1)?.extract().unwrap();
                            Ok(KmerIndexEntry::<97, Store97, u32> {
                                key: kmer.0.into(),
                                val,
                            })
                        })
                });
            Ok(
                Self(
                    KmerIndex::<
                        97,
                        Store97,
                        u32,
                    >::build_index(
                            kmer_entry_iter.map(|e| e.unwrap()),
                            path,
                            buffer_size,
                        )
                        .unwrap(),
                ),
            )
        }
        /// Build the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)
        pub fn build_dna(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
            index: u64,
            modulo: u64,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let dna_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let dna: PyDNA = base_tuple.get_item(0)?.extract().unwrap();
                            let val: u32 = base_tuple.get_item(0)?.extract().unwrap();
                            Ok((dna, val))
                        })
                });
            let kmer_iter = dna_entry_iter
                .map(|e| e.unwrap())
                .flat_map(|(dna, val)| {
                    let kmer_it: CanonicalKmerIterator<97, Store97> = (&dna.0).into();
                    let kmer_vec: Vec<KmerIndexEntry<97, Store97, u32>> = kmer_it
                        .filter(|kmer| kmer.hash() % modulo == index)
                        .map(move |kmer| KmerIndexEntry::<97, Store97, u32> {
                            key: kmer,
                            val,
                        })
                        .collect();
                    kmer_vec.into_iter()
                });
            Ok(
                Self(
                    KmerIndex::<
                        97,
                        Store97,
                        u32,
                    >::build_index(kmer_iter, path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn intersection_index(
            &self,
            other: &KmerSet97,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(IntSetu32(self.0.join_index::<()>(other.0.clone(), path, buffer_size)))
        }
        pub fn intersection_iter(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            Ok((i.extract::<PyKmer97>().unwrap().0.into(), ()))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntSetu32(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn get_all(&self, kmer: PyKmer97) -> PyResult<Vec<u32>> {
            match self.0.get_all(kmer.0.into()) {
                Ok(iter) => Ok(iter.collect()),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, kmer: PyKmer97) -> PyResult<u32> {
            match self.0.get(kmer.0.into()) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(KmerIndex::<97, Store97, u32>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIterator97u32>> {
            let iter = IndexIterator97u32(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
        fn size() -> PyResult<usize> {
            Ok(97)
        }
        pub fn join_iteru8(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer97>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u8>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu32u8(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu8(
            &self,
            other: &KmerIndex97u8,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu32u8(
                    self.0.join_index::<u8>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru16(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer97>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u16>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu32u16(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu16(
            &self,
            other: &KmerIndex97u16,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu32u16(
                    self.0.join_index::<u16>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru32(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer97>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u32>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu32u32(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu32(
            &self,
            other: &KmerIndex97u32,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu32u32(
                    self.0.join_index::<u32>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru64(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer97>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u64>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu32u64(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu64(
            &self,
            other: &KmerIndex97u64,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu32u64(
                    self.0.join_index::<u64>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru128(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer97>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u128>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu32u128(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu128(
            &self,
            other: &KmerIndex97u128,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu32u128(
                    self.0.join_index::<u128>(other.0.clone(), path, buffer_size),
                ),
            )
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<KmerIndex97u32>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<KmerIndex97u32> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex97u32::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build_dna",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex97u32::__pymethod_build_dna__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build_dna($cls, iterator, index_path, buffer_size, index, modulo)\n--\n\nBuild the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_index",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u32::__pymethod_intersection_index__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_index($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_iter",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u32::__pymethod_intersection_iter__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_iter($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"get_all",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u32::__pymethod_get_all__,
                                        )
                                    }
                                    trampoline
                                },
                                c"get_all($self, kmer)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Static(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                    c"size",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            unsafe {
                                                ::pyo3::impl_::trampoline::noargs(
                                                    _slf,
                                                    _args,
                                                    KmerIndex97u32::__pymethod_size__,
                                                )
                                            }
                                        }
                                        trampoline
                                    },
                                    c"size()\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_STATIC),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u32::__pymethod_join_iteru8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru8($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u32::__pymethod_join_indexu8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu8($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u32::__pymethod_join_iteru16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru16($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u32::__pymethod_join_indexu16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu16($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u32::__pymethod_join_iteru32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru32($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u32::__pymethod_join_indexu32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu32($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u32::__pymethod_join_iteru64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru64($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u32::__pymethod_join_indexu64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu64($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u32::__pymethod_join_iteru128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru128($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u32::__pymethod_join_indexu128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu128($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                KmerIndex97u32::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                KmerIndex97u32::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<KmerIndex97u32>
                                for PyClassImplCollector<KmerIndex97u32> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    KmerIndex97u32::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                KmerIndex97u32::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex97u32 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u32::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_build_dna__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u32::build_dna;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build_dna",
                positional_parameter_names: &[
                    "iterator",
                    "index_path",
                    "buffer_size",
                    "index",
                    "modulo",
                ],
                positional_only_parameters: 0usize,
                required_positional_parameters: 5usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 5usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_4 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[3usize].as_deref(),
                            )
                        },
                        &mut holder_3,
                        "index",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[4usize].as_deref(),
                            )
                        },
                        &mut holder_4,
                        "modulo",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_index__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u32::intersection_index;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_index",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_iter__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u32::intersection_iter;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_iter",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_get_all__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u32::get_all;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "get_all",
                positional_parameter_names: &["kmer"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "kmer",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = KmerIndex97u32::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex97u32::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex97u32,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u32::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex97u32::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex97u32,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "kmer",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = KmerIndex97u32::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex97u32::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<KmerIndex97u32> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u32::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = KmerIndex97u32::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<KmerIndex97u32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod_size__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u32::size;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function();
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u32::join_iteru8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru8",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u32::join_indexu8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu8",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u32::join_iteru16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru16",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u32::join_indexu16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu16",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u32::join_iteru32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru32",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u32::join_indexu32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu32",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u32::join_iteru64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru64",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u32::join_indexu64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu64",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u32::join_iteru128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru128",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u32::join_indexu128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu128",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
    }
    pub struct KmerIndex97u64(pub KmerIndex<97, Store97, u64>);
    #[automatically_derived]
    impl ::core::clone::Clone for KmerIndex97u64 {
        #[inline]
        fn clone(&self) -> KmerIndex97u64 {
            KmerIndex97u64(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for KmerIndex97u64 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for KmerIndex97u64 {
        const NAME: &'static str = "KmerIndex97u64";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <KmerIndex97u64 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for KmerIndex97u64 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a KmerIndex97u64 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, KmerIndex97u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut KmerIndex97u64 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, KmerIndex97u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for KmerIndex97u64 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for KmerIndex97u64 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<KmerIndex97u64>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for KmerIndex97u64 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<KmerIndex97u64>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<KmerIndex97u64> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex97u64 {}
    impl KmerIndex97u64 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex97u64 {}
    impl KmerIndex97u64 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let kmer_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let kmer: PyKmer97 = base_tuple
                                .get_item(0)?
                                .extract()
                                .unwrap();
                            let val: u64 = base_tuple.get_item(1)?.extract().unwrap();
                            Ok(KmerIndexEntry::<97, Store97, u64> {
                                key: kmer.0.into(),
                                val,
                            })
                        })
                });
            Ok(
                Self(
                    KmerIndex::<
                        97,
                        Store97,
                        u64,
                    >::build_index(
                            kmer_entry_iter.map(|e| e.unwrap()),
                            path,
                            buffer_size,
                        )
                        .unwrap(),
                ),
            )
        }
        /// Build the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)
        pub fn build_dna(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
            index: u64,
            modulo: u64,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let dna_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let dna: PyDNA = base_tuple.get_item(0)?.extract().unwrap();
                            let val: u64 = base_tuple.get_item(0)?.extract().unwrap();
                            Ok((dna, val))
                        })
                });
            let kmer_iter = dna_entry_iter
                .map(|e| e.unwrap())
                .flat_map(|(dna, val)| {
                    let kmer_it: CanonicalKmerIterator<97, Store97> = (&dna.0).into();
                    let kmer_vec: Vec<KmerIndexEntry<97, Store97, u64>> = kmer_it
                        .filter(|kmer| kmer.hash() % modulo == index)
                        .map(move |kmer| KmerIndexEntry::<97, Store97, u64> {
                            key: kmer,
                            val,
                        })
                        .collect();
                    kmer_vec.into_iter()
                });
            Ok(
                Self(
                    KmerIndex::<
                        97,
                        Store97,
                        u64,
                    >::build_index(kmer_iter, path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn intersection_index(
            &self,
            other: &KmerSet97,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(IntSetu64(self.0.join_index::<()>(other.0.clone(), path, buffer_size)))
        }
        pub fn intersection_iter(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            Ok((i.extract::<PyKmer97>().unwrap().0.into(), ()))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntSetu64(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn get_all(&self, kmer: PyKmer97) -> PyResult<Vec<u64>> {
            match self.0.get_all(kmer.0.into()) {
                Ok(iter) => Ok(iter.collect()),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, kmer: PyKmer97) -> PyResult<u64> {
            match self.0.get(kmer.0.into()) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(KmerIndex::<97, Store97, u64>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIterator97u64>> {
            let iter = IndexIterator97u64(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
        fn size() -> PyResult<usize> {
            Ok(97)
        }
        pub fn join_iteru8(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer97>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u8>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu64u8(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu8(
            &self,
            other: &KmerIndex97u8,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu64u8(
                    self.0.join_index::<u8>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru16(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer97>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u16>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu64u16(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu16(
            &self,
            other: &KmerIndex97u16,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu64u16(
                    self.0.join_index::<u16>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru32(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer97>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u32>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu64u32(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu32(
            &self,
            other: &KmerIndex97u32,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu64u32(
                    self.0.join_index::<u32>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru64(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer97>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u64>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu64u64(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu64(
            &self,
            other: &KmerIndex97u64,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu64u64(
                    self.0.join_index::<u64>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru128(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer97>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u128>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu64u128(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu128(
            &self,
            other: &KmerIndex97u128,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu64u128(
                    self.0.join_index::<u128>(other.0.clone(), path, buffer_size),
                ),
            )
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<KmerIndex97u64>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<KmerIndex97u64> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex97u64::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build_dna",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex97u64::__pymethod_build_dna__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build_dna($cls, iterator, index_path, buffer_size, index, modulo)\n--\n\nBuild the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_index",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u64::__pymethod_intersection_index__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_index($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_iter",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u64::__pymethod_intersection_iter__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_iter($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"get_all",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u64::__pymethod_get_all__,
                                        )
                                    }
                                    trampoline
                                },
                                c"get_all($self, kmer)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Static(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                    c"size",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            unsafe {
                                                ::pyo3::impl_::trampoline::noargs(
                                                    _slf,
                                                    _args,
                                                    KmerIndex97u64::__pymethod_size__,
                                                )
                                            }
                                        }
                                        trampoline
                                    },
                                    c"size()\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_STATIC),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u64::__pymethod_join_iteru8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru8($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u64::__pymethod_join_indexu8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu8($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u64::__pymethod_join_iteru16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru16($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u64::__pymethod_join_indexu16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu16($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u64::__pymethod_join_iteru32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru32($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u64::__pymethod_join_indexu32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu32($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u64::__pymethod_join_iteru64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru64($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u64::__pymethod_join_indexu64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu64($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u64::__pymethod_join_iteru128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru128($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u64::__pymethod_join_indexu128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu128($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                KmerIndex97u64::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                KmerIndex97u64::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<KmerIndex97u64>
                                for PyClassImplCollector<KmerIndex97u64> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    KmerIndex97u64::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                KmerIndex97u64::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex97u64 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u64::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_build_dna__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u64::build_dna;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build_dna",
                positional_parameter_names: &[
                    "iterator",
                    "index_path",
                    "buffer_size",
                    "index",
                    "modulo",
                ],
                positional_only_parameters: 0usize,
                required_positional_parameters: 5usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 5usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_4 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[3usize].as_deref(),
                            )
                        },
                        &mut holder_3,
                        "index",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[4usize].as_deref(),
                            )
                        },
                        &mut holder_4,
                        "modulo",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_index__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u64::intersection_index;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_index",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_iter__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u64::intersection_iter;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_iter",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_get_all__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u64::get_all;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "get_all",
                positional_parameter_names: &["kmer"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "kmer",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = KmerIndex97u64::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex97u64::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex97u64,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u64::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex97u64::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex97u64,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "kmer",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = KmerIndex97u64::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex97u64::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<KmerIndex97u64> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u64::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = KmerIndex97u64::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<KmerIndex97u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod_size__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u64::size;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function();
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u64::join_iteru8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru8",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u64::join_indexu8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu8",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u64::join_iteru16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru16",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u64::join_indexu16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu16",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u64::join_iteru32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru32",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u64::join_indexu32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu32",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u64::join_iteru64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru64",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u64::join_indexu64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu64",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u64::join_iteru128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru128",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u64::join_indexu128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu128",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
    }
    pub struct KmerIndex97u128(pub KmerIndex<97, Store97, u128>);
    #[automatically_derived]
    impl ::core::clone::Clone for KmerIndex97u128 {
        #[inline]
        fn clone(&self) -> KmerIndex97u128 {
            KmerIndex97u128(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for KmerIndex97u128 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for KmerIndex97u128 {
        const NAME: &'static str = "KmerIndex97u128";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <KmerIndex97u128 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for KmerIndex97u128 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a KmerIndex97u128 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, KmerIndex97u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut KmerIndex97u128 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, KmerIndex97u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for KmerIndex97u128 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for KmerIndex97u128 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<KmerIndex97u128>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for KmerIndex97u128 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<KmerIndex97u128>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<KmerIndex97u128> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex97u128 {}
    impl KmerIndex97u128 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex97u128 {}
    impl KmerIndex97u128 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let kmer_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let kmer: PyKmer97 = base_tuple
                                .get_item(0)?
                                .extract()
                                .unwrap();
                            let val: u128 = base_tuple.get_item(1)?.extract().unwrap();
                            Ok(KmerIndexEntry::<97, Store97, u128> {
                                key: kmer.0.into(),
                                val,
                            })
                        })
                });
            Ok(
                Self(
                    KmerIndex::<
                        97,
                        Store97,
                        u128,
                    >::build_index(
                            kmer_entry_iter.map(|e| e.unwrap()),
                            path,
                            buffer_size,
                        )
                        .unwrap(),
                ),
            )
        }
        /// Build the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)
        pub fn build_dna(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
            index: u64,
            modulo: u64,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let dna_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let dna: PyDNA = base_tuple.get_item(0)?.extract().unwrap();
                            let val: u128 = base_tuple.get_item(0)?.extract().unwrap();
                            Ok((dna, val))
                        })
                });
            let kmer_iter = dna_entry_iter
                .map(|e| e.unwrap())
                .flat_map(|(dna, val)| {
                    let kmer_it: CanonicalKmerIterator<97, Store97> = (&dna.0).into();
                    let kmer_vec: Vec<KmerIndexEntry<97, Store97, u128>> = kmer_it
                        .filter(|kmer| kmer.hash() % modulo == index)
                        .map(move |kmer| KmerIndexEntry::<97, Store97, u128> {
                            key: kmer,
                            val,
                        })
                        .collect();
                    kmer_vec.into_iter()
                });
            Ok(
                Self(
                    KmerIndex::<
                        97,
                        Store97,
                        u128,
                    >::build_index(kmer_iter, path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn intersection_index(
            &self,
            other: &KmerSet97,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(IntSetu128(self.0.join_index::<()>(other.0.clone(), path, buffer_size)))
        }
        pub fn intersection_iter(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            Ok((i.extract::<PyKmer97>().unwrap().0.into(), ()))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntSetu128(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn get_all(&self, kmer: PyKmer97) -> PyResult<Vec<u128>> {
            match self.0.get_all(kmer.0.into()) {
                Ok(iter) => Ok(iter.collect()),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, kmer: PyKmer97) -> PyResult<u128> {
            match self.0.get(kmer.0.into()) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(KmerIndex::<97, Store97, u128>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIterator97u128>> {
            let iter = IndexIterator97u128(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
        fn size() -> PyResult<usize> {
            Ok(97)
        }
        pub fn join_iteru8(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer97>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u8>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu128u8(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu8(
            &self,
            other: &KmerIndex97u8,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu128u8(
                    self.0.join_index::<u8>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru16(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer97>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u16>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu128u16(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu16(
            &self,
            other: &KmerIndex97u16,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu128u16(
                    self.0.join_index::<u16>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru32(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer97>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u32>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu128u32(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu32(
            &self,
            other: &KmerIndex97u32,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu128u32(
                    self.0.join_index::<u32>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru64(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer97>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u64>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu128u64(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu64(
            &self,
            other: &KmerIndex97u64,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu128u64(
                    self.0.join_index::<u64>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru128(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer97>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u128>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu128u128(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu128(
            &self,
            other: &KmerIndex97u128,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu128u128(
                    self.0.join_index::<u128>(other.0.clone(), path, buffer_size),
                ),
            )
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<KmerIndex97u128>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<KmerIndex97u128> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex97u128::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build_dna",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex97u128::__pymethod_build_dna__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build_dna($cls, iterator, index_path, buffer_size, index, modulo)\n--\n\nBuild the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_index",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u128::__pymethod_intersection_index__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_index($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_iter",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u128::__pymethod_intersection_iter__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_iter($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"get_all",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u128::__pymethod_get_all__,
                                        )
                                    }
                                    trampoline
                                },
                                c"get_all($self, kmer)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Static(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                    c"size",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            unsafe {
                                                ::pyo3::impl_::trampoline::noargs(
                                                    _slf,
                                                    _args,
                                                    KmerIndex97u128::__pymethod_size__,
                                                )
                                            }
                                        }
                                        trampoline
                                    },
                                    c"size()\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_STATIC),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u128::__pymethod_join_iteru8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru8($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u128::__pymethod_join_indexu8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu8($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u128::__pymethod_join_iteru16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru16($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u128::__pymethod_join_indexu16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu16($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u128::__pymethod_join_iteru32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru32($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u128::__pymethod_join_indexu32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu32($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u128::__pymethod_join_iteru64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru64($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u128::__pymethod_join_indexu64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu64($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u128::__pymethod_join_iteru128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru128($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex97u128::__pymethod_join_indexu128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu128($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                KmerIndex97u128::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                KmerIndex97u128::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<KmerIndex97u128>
                                for PyClassImplCollector<KmerIndex97u128> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    KmerIndex97u128::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                KmerIndex97u128::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex97u128 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u128::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_build_dna__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u128::build_dna;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build_dna",
                positional_parameter_names: &[
                    "iterator",
                    "index_path",
                    "buffer_size",
                    "index",
                    "modulo",
                ],
                positional_only_parameters: 0usize,
                required_positional_parameters: 5usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 5usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_4 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[3usize].as_deref(),
                            )
                        },
                        &mut holder_3,
                        "index",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[4usize].as_deref(),
                            )
                        },
                        &mut holder_4,
                        "modulo",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_index__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u128::intersection_index;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_index",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_iter__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u128::intersection_iter;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_iter",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_get_all__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u128::get_all;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "get_all",
                positional_parameter_names: &["kmer"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "kmer",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = KmerIndex97u128::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex97u128::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex97u128,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u128::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex97u128::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex97u128,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "kmer",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = KmerIndex97u128::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex97u128::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<KmerIndex97u128> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u128::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = KmerIndex97u128::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<KmerIndex97u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod_size__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u128::size;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function();
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u128::join_iteru8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru8",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u128::join_indexu8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu8",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u128::join_iteru16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru16",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u128::join_indexu16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu16",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u128::join_iteru32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru32",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u128::join_indexu32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu32",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u128::join_iteru64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru64",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u128::join_indexu64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu64",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u128::join_iteru128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru128",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex97u128::join_indexu128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex97u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu128",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex97u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
    }
    m.add_class::<PyKmer97>()?;
    m.add_class::<KmerSet97>()?;
    m.add_class::<KmerIndex97u8>()?;
    m.add_class::<KmerIndex97u16>()?;
    m.add_class::<KmerIndex97u32>()?;
    m.add_class::<KmerIndex97u64>()?;
    m.add_class::<KmerIndex97u128>()?;
    pub struct BytesSerial2047(pub [u8; 8 * (2047 / 32 + 1)]);
    #[automatically_derived]
    impl ::core::clone::Clone for BytesSerial2047 {
        #[inline]
        fn clone(&self) -> BytesSerial2047 {
            BytesSerial2047(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for BytesSerial2047 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for BytesSerial2047 {
        const NAME: &'static str = "BytesSerial2047";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <BytesSerial2047 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for BytesSerial2047 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a BytesSerial2047 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, BytesSerial2047>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut BytesSerial2047 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, BytesSerial2047>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for BytesSerial2047 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for BytesSerial2047 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<BytesSerial2047>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for BytesSerial2047 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<BytesSerial2047>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<BytesSerial2047> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl BytesSerial2047 {}
    impl BytesSerial2047 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl BytesSerial2047 {}
    impl BytesSerial2047 {
        const VSIZE: usize = 8 * (2047 / 32 + 1);
        pub fn new(data: &Bound<'_, PyAny>) -> PyResult<Self> {
            let slice: &[u8] = data.downcast::<PyBytes>()?.extract::<&[u8]>().unwrap();
            if slice.len() != Self::VSIZE {
                return Err(
                    PyValueError::new_err(
                        ::alloc::__export::must_use({
                            let res = ::alloc::fmt::format(
                                format_args!(
                                    "Expecting {0} size got {1}",
                                    Self::VSIZE,
                                    slice.len(),
                                ),
                            );
                            res
                        }),
                    ),
                );
            }
            Ok(Self(slice.try_into().unwrap()))
        }
        fn __bytes__(slf: PyRef<Self>) -> PyResult<Bound<'_, PyBytes>> {
            Ok(PyBytes::new(slf.py(), slf.0.as_slice()))
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<BytesSerial2047>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<BytesSerial2047> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                c"__bytes__",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        unsafe {
                                            ::pyo3::impl_::trampoline::noargs(
                                                _slf,
                                                _args,
                                                BytesSerial2047::__pymethod___bytes____,
                                            )
                                        }
                                    }
                                    trampoline
                                },
                                c"__bytes__($self)\n--\n\n",
                            ),
                        ),
                    ),
                ],
                slots: &[
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<BytesSerial2047>
                                for PyClassImplCollector<BytesSerial2047> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(data)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    BytesSerial2047::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl BytesSerial2047 {
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = BytesSerial2047::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <BytesSerial2047 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["data"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = BytesSerial2047::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "data",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<BytesSerial2047> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        unsafe fn __pymethod___bytes____<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = BytesSerial2047::__bytes__;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .downcast::<BytesSerial2047>()
                        .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                        .and_then(
                            #[allow(
                                unknown_lints,
                                clippy::unnecessary_fallible_conversions
                            )]
                            |bound| {
                                ::std::convert::TryFrom::try_from(bound)
                                    .map_err(::std::convert::Into::into)
                            },
                        )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
    }
    impl From<BytesSerial2047> for SimdDataStore<2047> {
        fn from(value: BytesSerial2047) -> Self {
            unsafe {
                let ptr = value.0.as_ptr() as *const u64;
                let narray: [u64; 2047 / 32 + 1] = std::slice::from_raw_parts(
                        ptr,
                        2047 / 32 + 1,
                    )
                    .try_into()
                    .unwrap();
                Self(Simd::from_array(narray))
            }
        }
    }
    impl From<SimdDataStore<2047>> for BytesSerial2047 {
        fn from(value: SimdDataStore<2047>) -> Self {
            Self([0; 8 * (2047 / 32 + 1)])
        }
    }
    pub struct PyKmer2047(pub PyKmer<2047, SimdDataStore<2047>>);
    #[automatically_derived]
    impl ::core::clone::Clone for PyKmer2047 {
        #[inline]
        fn clone(&self) -> PyKmer2047 {
            PyKmer2047(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for PyKmer2047 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for PyKmer2047 {
        const NAME: &'static str = "PyKmer2047";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <PyKmer2047 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for PyKmer2047 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a PyKmer2047 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, PyKmer2047>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut PyKmer2047 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, PyKmer2047>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for PyKmer2047 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for PyKmer2047 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<PyKmer2047>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for PyKmer2047 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<PyKmer2047>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<PyKmer2047> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl PyKmer2047 {}
    impl PyKmer2047 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl PyKmer2047 {}
    impl PyKmer2047 {
        pub fn new(data: BytesSerial2047) -> PyResult<Self> {
            Ok(
                Self(
                    PyKmer::<
                        2047,
                        SimdDataStore<2047>,
                    >(Kmer::<2047, SimdDataStore<2047>>(data.into())),
                ),
            )
        }
        pub fn enumerate_canonical_kmer(
            _: &Bound<'_, PyType>,
            dna: PyDNA,
        ) -> PyResult<Vec<Self>> {
            let it: CanonicalKmerIterator<2047, SimdDataStore<2047>> = (&(dna.0))
                .try_into()
                .unwrap();
            Ok(it.map(|u| Self(u.into())).collect())
        }
        pub fn count__kmer(_: &Bound<'_, PyType>, dna: PyDNA) -> PyResult<usize> {
            let it: KmerIterator<2047, SimdDataStore<2047>> = (&(dna.0))
                .try_into()
                .unwrap();
            Ok(it.count())
        }
        pub fn enumerate_kmer(_: &Bound<'_, PyType>, dna: PyDNA) -> PyResult<Vec<Self>> {
            let it: KmerIterator<2047, SimdDataStore<2047>> = (&(dna.0))
                .try_into()
                .unwrap();
            Ok(it.map(|u| Self(u.into())).collect())
        }
        pub fn size() -> PyResult<usize> {
            Ok(2047)
        }
        pub fn add_left_nucleotid(&self, n: PyNucleotid) -> PyResult<Self> {
            Ok(Self(self.0.0.append_left(n.0).into()))
        }
        pub fn add_right_nucleotid(&self, n: PyNucleotid) -> PyResult<Self> {
            Ok(Self(self.0.0.append(n.0).into()))
        }
        pub fn reverse_complement(&self) -> PyResult<Self> {
            Ok(Self(self.0.0.rc().into()))
        }
        pub fn canonical(&self) -> PyResult<Self> {
            Ok(Self(self.0.0.normalize().into()))
        }
        pub fn is_canonical(&self) -> PyResult<bool> {
            Ok(self.0.0 == self.0.0.normalize())
        }
        pub fn data(&self) -> PyResult<BytesSerial2047> {
            Ok(self.0.0.get_data().into())
        }
        pub fn __hash__(&self) -> PyResult<u64> {
            Ok(self.0.0.hash())
        }
        pub fn __repr__(&self) -> PyResult<String> {
            Ok(
                ::alloc::__export::must_use({
                    let res = ::alloc::fmt::format(format_args!("{0}", &self.0.0));
                    res
                }),
            )
        }
        pub fn __str__(&self) -> PyResult<String> {
            Ok((&self.0.0).into())
        }
        pub fn __lt__(&self, other: Self) -> PyResult<bool> {
            Ok(self.0.0 <= other.0.0)
        }
        pub fn __gt__(&self, other: Self) -> PyResult<bool> {
            Ok(self.0.0 >= other.0.0)
        }
        pub fn __eq__(&self, other: Self) -> PyResult<bool> {
            Ok(self.0.0 == other.0.0)
        }
    }
    impl PyKmer2047 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___lt____(
            py: ::pyo3::Python,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyKmer2047::__lt__(
                match ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    PyKmer2047,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                ) {
                    ::std::result::Result::Ok(value) => value,
                    ::std::result::Result::Err(_) => {
                        return ::pyo3::impl_::callback::convert(py, py.NotImplemented());
                    }
                },
                match ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "other",
                ) {
                    ::std::result::Result::Ok(value) => value,
                    ::std::result::Result::Err(_) => {
                        return ::pyo3::impl_::callback::convert(py, py.NotImplemented());
                    }
                },
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    impl ::pyo3::impl_::pyclass::PyClass__lt__SlotFragment<PyKmer2047>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<PyKmer2047> {
        #[inline]
        unsafe fn __lt__(
            self,
            py: ::pyo3::Python,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            PyKmer2047::__pymethod___lt____(py, _raw_slf, arg0)
        }
    }
    impl PyKmer2047 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___gt____(
            py: ::pyo3::Python,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyKmer2047::__gt__(
                match ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    PyKmer2047,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                ) {
                    ::std::result::Result::Ok(value) => value,
                    ::std::result::Result::Err(_) => {
                        return ::pyo3::impl_::callback::convert(py, py.NotImplemented());
                    }
                },
                match ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "other",
                ) {
                    ::std::result::Result::Ok(value) => value,
                    ::std::result::Result::Err(_) => {
                        return ::pyo3::impl_::callback::convert(py, py.NotImplemented());
                    }
                },
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    impl ::pyo3::impl_::pyclass::PyClass__gt__SlotFragment<PyKmer2047>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<PyKmer2047> {
        #[inline]
        unsafe fn __gt__(
            self,
            py: ::pyo3::Python,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            PyKmer2047::__pymethod___gt____(py, _raw_slf, arg0)
        }
    }
    impl PyKmer2047 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___eq____(
            py: ::pyo3::Python,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyKmer2047::__eq__(
                match ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    PyKmer2047,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                ) {
                    ::std::result::Result::Ok(value) => value,
                    ::std::result::Result::Err(_) => {
                        return ::pyo3::impl_::callback::convert(py, py.NotImplemented());
                    }
                },
                match ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "other",
                ) {
                    ::std::result::Result::Ok(value) => value,
                    ::std::result::Result::Err(_) => {
                        return ::pyo3::impl_::callback::convert(py, py.NotImplemented());
                    }
                },
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    impl ::pyo3::impl_::pyclass::PyClass__eq__SlotFragment<PyKmer2047>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<PyKmer2047> {
        #[inline]
        unsafe fn __eq__(
            self,
            py: ::pyo3::Python,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            PyKmer2047::__pymethod___eq____(py, _raw_slf, arg0)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<PyKmer2047>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<PyKmer2047> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"enumerate_canonical_kmer",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                PyKmer2047::__pymethod_enumerate_canonical_kmer__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"enumerate_canonical_kmer($cls, dna)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"count__kmer",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                PyKmer2047::__pymethod_count__kmer__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"count__kmer($cls, dna)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"enumerate_kmer",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                PyKmer2047::__pymethod_enumerate_kmer__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"enumerate_kmer($cls, dna)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Static(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                    c"size",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            unsafe {
                                                ::pyo3::impl_::trampoline::noargs(
                                                    _slf,
                                                    _args,
                                                    PyKmer2047::__pymethod_size__,
                                                )
                                            }
                                        }
                                        trampoline
                                    },
                                    c"size()\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_STATIC),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"add_left_nucleotid",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            PyKmer2047::__pymethod_add_left_nucleotid__,
                                        )
                                    }
                                    trampoline
                                },
                                c"add_left_nucleotid($self, n)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"add_right_nucleotid",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            PyKmer2047::__pymethod_add_right_nucleotid__,
                                        )
                                    }
                                    trampoline
                                },
                                c"add_right_nucleotid($self, n)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                c"reverse_complement",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        unsafe {
                                            ::pyo3::impl_::trampoline::noargs(
                                                _slf,
                                                _args,
                                                PyKmer2047::__pymethod_reverse_complement__,
                                            )
                                        }
                                    }
                                    trampoline
                                },
                                c"reverse_complement($self)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                c"canonical",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        unsafe {
                                            ::pyo3::impl_::trampoline::noargs(
                                                _slf,
                                                _args,
                                                PyKmer2047::__pymethod_canonical__,
                                            )
                                        }
                                    }
                                    trampoline
                                },
                                c"canonical($self)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                c"is_canonical",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        unsafe {
                                            ::pyo3::impl_::trampoline::noargs(
                                                _slf,
                                                _args,
                                                PyKmer2047::__pymethod_is_canonical__,
                                            )
                                        }
                                    }
                                    trampoline
                                },
                                c"is_canonical($self)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Getter(
                            ::pyo3::impl_::pymethods::PyGetterDef::new(
                                c"data",
                                PyKmer2047::__pymethod_get_data__,
                                c"",
                            ),
                        ),
                    ),
                ],
                slots: &[
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<PyKmer2047>
                                for PyClassImplCollector<PyKmer2047> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(data)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    PyKmer2047::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_hash_t {
                            ::pyo3::impl_::trampoline::hashfunc(
                                _slf,
                                PyKmer2047::__pymethod___hash____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_hash,
                            pfunc: trampoline as ::pyo3::ffi::hashfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::reprfunc(
                                _slf,
                                PyKmer2047::__pymethod___repr____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_repr,
                            pfunc: trampoline as ::pyo3::ffi::reprfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::reprfunc(
                                _slf,
                                PyKmer2047::__pymethod___str____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_str,
                            pfunc: trampoline as ::pyo3::ffi::reprfunc as _,
                        }
                    },
                    {
                        #[allow(unknown_lints, non_local_definitions)]
                        impl PyKmer2047 {
                            #[allow(non_snake_case)]
                            unsafe extern "C" fn __pymethod___richcmp____(
                                slf: *mut ::pyo3::ffi::PyObject,
                                other: *mut ::pyo3::ffi::PyObject,
                                op: ::std::os::raw::c_int,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                impl ::pyo3::impl_::pyclass::HasCustomRichCmp
                                for PyKmer2047 {}
                                ::pyo3::impl_::trampoline::richcmpfunc(
                                    slf,
                                    other,
                                    op,
                                    |py, slf, other, op| {
                                        use ::pyo3::class::basic::CompareOp;
                                        use ::pyo3::impl_::pyclass::*;
                                        let collector = PyClassImplCollector::<PyKmer2047>::new();
                                        match CompareOp::from_raw(op).expect("invalid compareop") {
                                            CompareOp::Lt => collector.__lt__(py, slf, other),
                                            CompareOp::Le => collector.__le__(py, slf, other),
                                            CompareOp::Eq => collector.__eq__(py, slf, other),
                                            CompareOp::Ne => collector.__ne__(py, slf, other),
                                            CompareOp::Gt => collector.__gt__(py, slf, other),
                                            CompareOp::Ge => collector.__ge__(py, slf, other),
                                        }
                                    },
                                )
                            }
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_richcompare,
                            pfunc: <PyKmer2047>::__pymethod___richcmp____
                                as ::pyo3::ffi::richcmpfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl PyKmer2047 {
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = PyKmer2047::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyKmer2047 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["data"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyKmer2047::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "data",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<PyKmer2047> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        unsafe fn __pymethod_enumerate_canonical_kmer__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer2047::enumerate_canonical_kmer;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyKmer2047 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "enumerate_canonical_kmer",
                positional_parameter_names: &["dna"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "dna",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_count__kmer__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer2047::count__kmer;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyKmer2047 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "count__kmer",
                positional_parameter_names: &["dna"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "dna",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_enumerate_kmer__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer2047::enumerate_kmer;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyKmer2047 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "enumerate_kmer",
                positional_parameter_names: &["dna"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "dna",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_size__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer2047::size;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function();
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_add_left_nucleotid__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer2047::add_left_nucleotid;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyKmer2047 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "add_left_nucleotid",
                positional_parameter_names: &["n"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyKmer2047,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "n",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_add_right_nucleotid__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer2047::add_right_nucleotid;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <PyKmer2047 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "add_right_nucleotid",
                positional_parameter_names: &["n"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyKmer2047,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "n",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_reverse_complement__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer2047::reverse_complement;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyKmer2047,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_0,
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_canonical__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer2047::canonical;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyKmer2047,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_0,
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_is_canonical__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer2047::is_canonical;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyKmer2047,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_0,
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_get_data__(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = ::pyo3::impl_::callback::convert(
                py,
                PyKmer2047::data(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyKmer2047,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_0,
                    )?,
                ),
            );
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___hash____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_hash_t> {
            let function = PyKmer2047::__hash__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let _result: ::pyo3::PyResult<::pyo3::impl_::callback::HashCallbackOutput> = ::pyo3::impl_::callback::convert(
                py,
                PyKmer2047::__hash__(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        PyKmer2047,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_0,
                    )?,
                ),
            );
            ::pyo3::impl_::callback::convert(py, _result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___repr____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer2047::__repr__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyKmer2047::__repr__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    PyKmer2047,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___str____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = PyKmer2047::__str__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = PyKmer2047::__str__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    PyKmer2047,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
    }
    type Store2047 = SimdDataStore<2047>;
    pub struct KmerSet2047(KmerIndex<2047, Store2047, ()>);
    #[automatically_derived]
    impl ::core::clone::Clone for KmerSet2047 {
        #[inline]
        fn clone(&self) -> KmerSet2047 {
            KmerSet2047(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for KmerSet2047 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for KmerSet2047 {
        const NAME: &'static str = "KmerSet2047";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <KmerSet2047 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for KmerSet2047 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a KmerSet2047 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, KmerSet2047>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut KmerSet2047 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, KmerSet2047>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for KmerSet2047 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for KmerSet2047 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<KmerSet2047>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for KmerSet2047 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<KmerSet2047>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<KmerSet2047> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerSet2047 {}
    impl KmerSet2047 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerSet2047 {}
    impl KmerSet2047 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let kmer_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let kmer = base_tuple
                                .get_item(0)?
                                .extract::<PyKmer2047>()
                                .unwrap()
                                .0;
                            Ok(KmerIndexEntry::<2047, Store2047, ()> {
                                key: kmer.into(),
                                val: (),
                            })
                        })
                });
            Ok(
                Self(
                    KmerIndex::<
                        2047,
                        Store2047,
                        (),
                    >::build_index(
                            kmer_entry_iter.map(|e| e.unwrap()),
                            path,
                            buffer_size,
                        )
                        .unwrap(),
                ),
            )
        }
        pub fn build_dna(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
            index: u64,
            modulo: u64,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let dna_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let dna = i.extract::<PyDNA>().unwrap().0;
                            Ok(dna)
                        })
                });
            let kmer_iter = dna_entry_iter
                .map(|e| e.unwrap())
                .flat_map(|dna| {
                    let kmer_it: CanonicalKmerIterator<2047, Store2047> = (&dna).into();
                    let kmer_it_filt = kmer_it
                        .filter(|kmer| kmer.hash() % modulo == index)
                        .map(move |kmer| KmerIndexEntry::<2047, Store2047, ()> {
                            key: kmer,
                            val: (),
                        });
                    let kmer_vec: Vec<KmerIndexEntry<2047, Store2047, ()>> = kmer_it_filt
                        .collect();
                    kmer_vec.into_iter()
                });
            Ok(
                Self(
                    KmerIndex::<
                        2047,
                        Store2047,
                        (),
                    >::build_index(kmer_iter, path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __contains__(&self, kmer: PyKmer2047) -> PyResult<bool> {
            match self.0.get(kmer.0.into()) {
                Ok(_) => Ok(true),
                _ => Ok(false),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(KmerIndex::<2047, Store2047, ()>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexSetIterator2047Store2047>> {
            let iter = IndexSetIterator2047Store2047(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
        fn size() -> PyResult<usize> {
            Ok(2047)
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<KmerSet2047>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<KmerSet2047> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerSet2047::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build_dna",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerSet2047::__pymethod_build_dna__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build_dna($cls, iterator, index_path, buffer_size, index, modulo)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Static(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                    c"size",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            unsafe {
                                                ::pyo3::impl_::trampoline::noargs(
                                                    _slf,
                                                    _args,
                                                    KmerSet2047::__pymethod_size__,
                                                )
                                            }
                                        }
                                        trampoline
                                    },
                                    c"size()\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_STATIC),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                KmerSet2047::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> ::std::os::raw::c_int {
                            ::pyo3::impl_::trampoline::objobjproc(
                                _slf,
                                arg0,
                                KmerSet2047::__pymethod___contains____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_sq_contains,
                            pfunc: trampoline as ::pyo3::ffi::objobjproc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<KmerSet2047>
                                for PyClassImplCollector<KmerSet2047> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    KmerSet2047::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                KmerSet2047::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerSet2047 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerSet2047::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerSet2047 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_build_dna__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerSet2047::build_dna;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerSet2047 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build_dna",
                positional_parameter_names: &[
                    "iterator",
                    "index_path",
                    "buffer_size",
                    "index",
                    "modulo",
                ],
                positional_only_parameters: 0usize,
                required_positional_parameters: 5usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 5usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_4 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[3usize].as_deref(),
                            )
                        },
                        &mut holder_3,
                        "index",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[4usize].as_deref(),
                            )
                        },
                        &mut holder_4,
                        "modulo",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = KmerSet2047::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerSet2047::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerSet2047,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___contains____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::std::os::raw::c_int> {
            let function = KmerSet2047::__contains__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerSet2047::__contains__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerSet2047,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "kmer",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = KmerSet2047::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerSet2047 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerSet2047::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<KmerSet2047> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerSet2047::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = KmerSet2047::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<KmerSet2047>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod_size__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerSet2047::size;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function();
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
    }
    pub struct IndexSetIterator2047Store2047(IndexIterator<Kmer<2047, Store2047>, ()>);
    impl ::pyo3::types::DerefToPyAny for IndexSetIterator2047Store2047 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexSetIterator2047Store2047 {
        const NAME: &'static str = "IndexSetIterator2047Store2047";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexSetIterator2047Store2047 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexSetIterator2047Store2047 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexSetIterator2047Store2047 {
        type Holder = ::std::option::Option<
            ::pyo3::PyRef<'py, IndexSetIterator2047Store2047>,
        >;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexSetIterator2047Store2047 {
        type Holder = ::std::option::Option<
            ::pyo3::PyRefMut<'py, IndexSetIterator2047Store2047>,
        >;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexSetIterator2047Store2047 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexSetIterator2047Store2047 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexSetIterator2047Store2047>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexSetIterator2047Store2047 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexSetIterator2047Store2047,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexSetIterator2047Store2047> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexSetIterator2047Store2047 {}
    impl IndexSetIterator2047Store2047 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexSetIterator2047Store2047 {}
    impl IndexSetIterator2047Store2047 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<PyKmer2047> {
            match slf.0.next() {
                Some(index_entry) => Some(PyKmer2047(index_entry.key.into())),
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexSetIterator2047Store2047>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexSetIterator2047Store2047> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexSetIterator2047Store2047::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexSetIterator2047Store2047::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexSetIterator2047Store2047 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexSetIterator2047Store2047::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexSetIterator2047Store2047::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexSetIterator2047Store2047>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexSetIterator2047Store2047::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexSetIterator2047Store2047::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexSetIterator2047Store2047>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IndexIterator2047u8(IndexIterator<Kmer<2047, Store2047>, u8>);
    impl ::pyo3::types::DerefToPyAny for IndexIterator2047u8 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIterator2047u8 {
        const NAME: &'static str = "IndexIterator2047u8";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIterator2047u8 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIterator2047u8 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIterator2047u8 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIterator2047u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIterator2047u8 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIterator2047u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIterator2047u8 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIterator2047u8 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIterator2047u8>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIterator2047u8 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIterator2047u8,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIterator2047u8> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator2047u8 {}
    impl IndexIterator2047u8 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator2047u8 {}
    impl IndexIterator2047u8 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(PyKmer2047, u8)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((PyKmer2047(index_entry.key.into()), index_entry.val))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIterator2047u8>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIterator2047u8> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIterator2047u8::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIterator2047u8::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator2047u8 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator2047u8::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIterator2047u8::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator2047u8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator2047u8::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIterator2047u8::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator2047u8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IndexIterator2047u16(IndexIterator<Kmer<2047, Store2047>, u16>);
    impl ::pyo3::types::DerefToPyAny for IndexIterator2047u16 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIterator2047u16 {
        const NAME: &'static str = "IndexIterator2047u16";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIterator2047u16 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIterator2047u16 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIterator2047u16 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIterator2047u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIterator2047u16 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIterator2047u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIterator2047u16 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIterator2047u16 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIterator2047u16>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIterator2047u16 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIterator2047u16,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIterator2047u16> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator2047u16 {}
    impl IndexIterator2047u16 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator2047u16 {}
    impl IndexIterator2047u16 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(PyKmer2047, u16)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((PyKmer2047(index_entry.key.into()), index_entry.val))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIterator2047u16>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIterator2047u16> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIterator2047u16::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIterator2047u16::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator2047u16 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator2047u16::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIterator2047u16::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator2047u16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator2047u16::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIterator2047u16::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator2047u16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IndexIterator2047u32(IndexIterator<Kmer<2047, Store2047>, u32>);
    impl ::pyo3::types::DerefToPyAny for IndexIterator2047u32 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIterator2047u32 {
        const NAME: &'static str = "IndexIterator2047u32";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIterator2047u32 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIterator2047u32 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIterator2047u32 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIterator2047u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIterator2047u32 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIterator2047u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIterator2047u32 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIterator2047u32 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIterator2047u32>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIterator2047u32 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIterator2047u32,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIterator2047u32> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator2047u32 {}
    impl IndexIterator2047u32 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator2047u32 {}
    impl IndexIterator2047u32 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(PyKmer2047, u32)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((PyKmer2047(index_entry.key.into()), index_entry.val))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIterator2047u32>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIterator2047u32> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIterator2047u32::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIterator2047u32::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator2047u32 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator2047u32::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIterator2047u32::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator2047u32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator2047u32::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIterator2047u32::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator2047u32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IndexIterator2047u64(IndexIterator<Kmer<2047, Store2047>, u64>);
    impl ::pyo3::types::DerefToPyAny for IndexIterator2047u64 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIterator2047u64 {
        const NAME: &'static str = "IndexIterator2047u64";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIterator2047u64 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIterator2047u64 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIterator2047u64 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIterator2047u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIterator2047u64 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, IndexIterator2047u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIterator2047u64 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIterator2047u64 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIterator2047u64>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIterator2047u64 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIterator2047u64,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIterator2047u64> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator2047u64 {}
    impl IndexIterator2047u64 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator2047u64 {}
    impl IndexIterator2047u64 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(PyKmer2047, u64)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((PyKmer2047(index_entry.key.into()), index_entry.val))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIterator2047u64>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIterator2047u64> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIterator2047u64::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIterator2047u64::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator2047u64 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator2047u64::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIterator2047u64::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator2047u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator2047u64::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIterator2047u64::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator2047u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct IndexIterator2047u128(IndexIterator<Kmer<2047, Store2047>, u128>);
    impl ::pyo3::types::DerefToPyAny for IndexIterator2047u128 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for IndexIterator2047u128 {
        const NAME: &'static str = "IndexIterator2047u128";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <IndexIterator2047u128 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for IndexIterator2047u128 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a IndexIterator2047u128 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, IndexIterator2047u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut IndexIterator2047u128 {
        type Holder = ::std::option::Option<
            ::pyo3::PyRefMut<'py, IndexIterator2047u128>,
        >;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for IndexIterator2047u128 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for IndexIterator2047u128 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<IndexIterator2047u128>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for IndexIterator2047u128 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<
            IndexIterator2047u128,
        >;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<IndexIterator2047u128> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator2047u128 {}
    impl IndexIterator2047u128 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator2047u128 {}
    impl IndexIterator2047u128 {
        fn __iter__(slf: PyRef<Self>) -> PyRef<Self> {
            slf
        }
        fn __next__(mut slf: PyRefMut<Self>) -> Option<(PyKmer2047, u128)> {
            match slf.0.next() {
                Some(index_entry) => {
                    Some((PyKmer2047(index_entry.key.into()), index_entry.val))
                }
                _ => None,
            }
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<IndexIterator2047u128>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<IndexIterator2047u128> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                IndexIterator2047u128::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::iternextfunc(
                                _slf,
                                IndexIterator2047u128::__pymethod___next____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iternext,
                            pfunc: trampoline as ::pyo3::ffi::iternextfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl IndexIterator2047u128 {
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator2047u128::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = IndexIterator2047u128::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator2047u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___next____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = IndexIterator2047u128::__next__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let _result = IndexIterator2047u128::__next__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<IndexIterator2047u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            use ::pyo3::impl_::pymethods::{
                IterBaseKind, IterOptionKind, IterResultOptionKind,
            };
            (&_result).iter_tag().convert(py, _result)
        }
    }
    pub struct KmerIndex2047u8(pub KmerIndex<2047, Store2047, u8>);
    #[automatically_derived]
    impl ::core::clone::Clone for KmerIndex2047u8 {
        #[inline]
        fn clone(&self) -> KmerIndex2047u8 {
            KmerIndex2047u8(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for KmerIndex2047u8 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for KmerIndex2047u8 {
        const NAME: &'static str = "KmerIndex2047u8";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <KmerIndex2047u8 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for KmerIndex2047u8 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a KmerIndex2047u8 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, KmerIndex2047u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut KmerIndex2047u8 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, KmerIndex2047u8>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for KmerIndex2047u8 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for KmerIndex2047u8 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<KmerIndex2047u8>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for KmerIndex2047u8 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<KmerIndex2047u8>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<KmerIndex2047u8> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex2047u8 {}
    impl KmerIndex2047u8 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex2047u8 {}
    impl KmerIndex2047u8 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let kmer_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let kmer: PyKmer2047 = base_tuple
                                .get_item(0)?
                                .extract()
                                .unwrap();
                            let val: u8 = base_tuple.get_item(1)?.extract().unwrap();
                            Ok(KmerIndexEntry::<2047, Store2047, u8> {
                                key: kmer.0.into(),
                                val,
                            })
                        })
                });
            Ok(
                Self(
                    KmerIndex::<
                        2047,
                        Store2047,
                        u8,
                    >::build_index(
                            kmer_entry_iter.map(|e| e.unwrap()),
                            path,
                            buffer_size,
                        )
                        .unwrap(),
                ),
            )
        }
        /// Build the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)
        pub fn build_dna(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
            index: u64,
            modulo: u64,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let dna_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let dna: PyDNA = base_tuple.get_item(0)?.extract().unwrap();
                            let val: u8 = base_tuple.get_item(0)?.extract().unwrap();
                            Ok((dna, val))
                        })
                });
            let kmer_iter = dna_entry_iter
                .map(|e| e.unwrap())
                .flat_map(|(dna, val)| {
                    let kmer_it: CanonicalKmerIterator<2047, Store2047> = (&dna.0)
                        .into();
                    let kmer_vec: Vec<KmerIndexEntry<2047, Store2047, u8>> = kmer_it
                        .filter(|kmer| kmer.hash() % modulo == index)
                        .map(move |kmer| KmerIndexEntry::<2047, Store2047, u8> {
                            key: kmer,
                            val,
                        })
                        .collect();
                    kmer_vec.into_iter()
                });
            Ok(
                Self(
                    KmerIndex::<
                        2047,
                        Store2047,
                        u8,
                    >::build_index(kmer_iter, path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn intersection_index(
            &self,
            other: &KmerSet2047,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(IntSetu8(self.0.join_index::<()>(other.0.clone(), path, buffer_size)))
        }
        pub fn intersection_iter(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            Ok((i.extract::<PyKmer2047>().unwrap().0.into(), ()))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntSetu8(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn get_all(&self, kmer: PyKmer2047) -> PyResult<Vec<u8>> {
            match self.0.get_all(kmer.0.into()) {
                Ok(iter) => Ok(iter.collect()),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, kmer: PyKmer2047) -> PyResult<u8> {
            match self.0.get(kmer.0.into()) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(KmerIndex::<2047, Store2047, u8>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIterator2047u8>> {
            let iter = IndexIterator2047u8(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
        fn size() -> PyResult<usize> {
            Ok(2047)
        }
        pub fn join_iteru8(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer2047>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u8>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu8u8(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu8(
            &self,
            other: &KmerIndex2047u8,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(IntIndexu8u8(self.0.join_index::<u8>(other.0.clone(), path, buffer_size)))
        }
        pub fn join_iteru16(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer2047>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u16>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu8u16(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu16(
            &self,
            other: &KmerIndex2047u16,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu8u16(
                    self.0.join_index::<u16>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru32(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer2047>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u32>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu8u32(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu32(
            &self,
            other: &KmerIndex2047u32,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu8u32(
                    self.0.join_index::<u32>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru64(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer2047>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u64>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu8u64(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu64(
            &self,
            other: &KmerIndex2047u64,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu8u64(
                    self.0.join_index::<u64>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru128(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer2047>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u128>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu8u128(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu128(
            &self,
            other: &KmerIndex2047u128,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu8u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu8u128(
                    self.0.join_index::<u128>(other.0.clone(), path, buffer_size),
                ),
            )
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<KmerIndex2047u8>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<KmerIndex2047u8> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex2047u8::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build_dna",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex2047u8::__pymethod_build_dna__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build_dna($cls, iterator, index_path, buffer_size, index, modulo)\n--\n\nBuild the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_index",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u8::__pymethod_intersection_index__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_index($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_iter",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u8::__pymethod_intersection_iter__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_iter($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"get_all",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u8::__pymethod_get_all__,
                                        )
                                    }
                                    trampoline
                                },
                                c"get_all($self, kmer)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Static(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                    c"size",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            unsafe {
                                                ::pyo3::impl_::trampoline::noargs(
                                                    _slf,
                                                    _args,
                                                    KmerIndex2047u8::__pymethod_size__,
                                                )
                                            }
                                        }
                                        trampoline
                                    },
                                    c"size()\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_STATIC),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u8::__pymethod_join_iteru8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru8($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u8::__pymethod_join_indexu8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu8($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u8::__pymethod_join_iteru16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru16($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u8::__pymethod_join_indexu16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu16($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u8::__pymethod_join_iteru32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru32($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u8::__pymethod_join_indexu32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu32($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u8::__pymethod_join_iteru64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru64($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u8::__pymethod_join_indexu64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu64($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u8::__pymethod_join_iteru128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru128($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u8::__pymethod_join_indexu128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu128($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                KmerIndex2047u8::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                KmerIndex2047u8::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<KmerIndex2047u8>
                                for PyClassImplCollector<KmerIndex2047u8> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    KmerIndex2047u8::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                KmerIndex2047u8::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex2047u8 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u8::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_build_dna__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u8::build_dna;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build_dna",
                positional_parameter_names: &[
                    "iterator",
                    "index_path",
                    "buffer_size",
                    "index",
                    "modulo",
                ],
                positional_only_parameters: 0usize,
                required_positional_parameters: 5usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 5usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_4 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[3usize].as_deref(),
                            )
                        },
                        &mut holder_3,
                        "index",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[4usize].as_deref(),
                            )
                        },
                        &mut holder_4,
                        "modulo",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_index__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u8::intersection_index;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_index",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_iter__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u8::intersection_iter;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_iter",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_get_all__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u8::get_all;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "get_all",
                positional_parameter_names: &["kmer"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "kmer",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = KmerIndex2047u8::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex2047u8::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex2047u8,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u8::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex2047u8::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex2047u8,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "kmer",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = KmerIndex2047u8::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex2047u8::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<KmerIndex2047u8> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u8::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = KmerIndex2047u8::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<KmerIndex2047u8>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod_size__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u8::size;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function();
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u8::join_iteru8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru8",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u8::join_indexu8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu8",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u8::join_iteru16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru16",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u8::join_indexu16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu16",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u8::join_iteru32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru32",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u8::join_indexu32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu32",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u8::join_iteru64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru64",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u8::join_indexu64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu64",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u8::join_iteru128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru128",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u8::join_indexu128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u8 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu128",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u8,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
    }
    pub struct KmerIndex2047u16(pub KmerIndex<2047, Store2047, u16>);
    #[automatically_derived]
    impl ::core::clone::Clone for KmerIndex2047u16 {
        #[inline]
        fn clone(&self) -> KmerIndex2047u16 {
            KmerIndex2047u16(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for KmerIndex2047u16 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for KmerIndex2047u16 {
        const NAME: &'static str = "KmerIndex2047u16";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <KmerIndex2047u16 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for KmerIndex2047u16 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a KmerIndex2047u16 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, KmerIndex2047u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut KmerIndex2047u16 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, KmerIndex2047u16>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for KmerIndex2047u16 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for KmerIndex2047u16 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<KmerIndex2047u16>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for KmerIndex2047u16 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<KmerIndex2047u16>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<KmerIndex2047u16> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex2047u16 {}
    impl KmerIndex2047u16 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex2047u16 {}
    impl KmerIndex2047u16 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let kmer_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let kmer: PyKmer2047 = base_tuple
                                .get_item(0)?
                                .extract()
                                .unwrap();
                            let val: u16 = base_tuple.get_item(1)?.extract().unwrap();
                            Ok(KmerIndexEntry::<2047, Store2047, u16> {
                                key: kmer.0.into(),
                                val,
                            })
                        })
                });
            Ok(
                Self(
                    KmerIndex::<
                        2047,
                        Store2047,
                        u16,
                    >::build_index(
                            kmer_entry_iter.map(|e| e.unwrap()),
                            path,
                            buffer_size,
                        )
                        .unwrap(),
                ),
            )
        }
        /// Build the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)
        pub fn build_dna(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
            index: u64,
            modulo: u64,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let dna_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let dna: PyDNA = base_tuple.get_item(0)?.extract().unwrap();
                            let val: u16 = base_tuple.get_item(0)?.extract().unwrap();
                            Ok((dna, val))
                        })
                });
            let kmer_iter = dna_entry_iter
                .map(|e| e.unwrap())
                .flat_map(|(dna, val)| {
                    let kmer_it: CanonicalKmerIterator<2047, Store2047> = (&dna.0)
                        .into();
                    let kmer_vec: Vec<KmerIndexEntry<2047, Store2047, u16>> = kmer_it
                        .filter(|kmer| kmer.hash() % modulo == index)
                        .map(move |kmer| KmerIndexEntry::<2047, Store2047, u16> {
                            key: kmer,
                            val,
                        })
                        .collect();
                    kmer_vec.into_iter()
                });
            Ok(
                Self(
                    KmerIndex::<
                        2047,
                        Store2047,
                        u16,
                    >::build_index(kmer_iter, path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn intersection_index(
            &self,
            other: &KmerSet2047,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(IntSetu16(self.0.join_index::<()>(other.0.clone(), path, buffer_size)))
        }
        pub fn intersection_iter(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            Ok((i.extract::<PyKmer2047>().unwrap().0.into(), ()))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntSetu16(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn get_all(&self, kmer: PyKmer2047) -> PyResult<Vec<u16>> {
            match self.0.get_all(kmer.0.into()) {
                Ok(iter) => Ok(iter.collect()),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, kmer: PyKmer2047) -> PyResult<u16> {
            match self.0.get(kmer.0.into()) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(KmerIndex::<2047, Store2047, u16>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIterator2047u16>> {
            let iter = IndexIterator2047u16(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
        fn size() -> PyResult<usize> {
            Ok(2047)
        }
        pub fn join_iteru8(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer2047>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u8>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu16u8(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu8(
            &self,
            other: &KmerIndex2047u8,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu16u8(
                    self.0.join_index::<u8>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru16(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer2047>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u16>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu16u16(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu16(
            &self,
            other: &KmerIndex2047u16,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu16u16(
                    self.0.join_index::<u16>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru32(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer2047>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u32>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu16u32(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu32(
            &self,
            other: &KmerIndex2047u32,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu16u32(
                    self.0.join_index::<u32>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru64(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer2047>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u64>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu16u64(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu64(
            &self,
            other: &KmerIndex2047u64,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu16u64(
                    self.0.join_index::<u64>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru128(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer2047>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u128>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu16u128(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu128(
            &self,
            other: &KmerIndex2047u128,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu16u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu16u128(
                    self.0.join_index::<u128>(other.0.clone(), path, buffer_size),
                ),
            )
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<KmerIndex2047u16>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<KmerIndex2047u16> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex2047u16::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build_dna",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex2047u16::__pymethod_build_dna__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build_dna($cls, iterator, index_path, buffer_size, index, modulo)\n--\n\nBuild the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_index",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u16::__pymethod_intersection_index__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_index($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_iter",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u16::__pymethod_intersection_iter__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_iter($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"get_all",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u16::__pymethod_get_all__,
                                        )
                                    }
                                    trampoline
                                },
                                c"get_all($self, kmer)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Static(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                    c"size",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            unsafe {
                                                ::pyo3::impl_::trampoline::noargs(
                                                    _slf,
                                                    _args,
                                                    KmerIndex2047u16::__pymethod_size__,
                                                )
                                            }
                                        }
                                        trampoline
                                    },
                                    c"size()\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_STATIC),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u16::__pymethod_join_iteru8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru8($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u16::__pymethod_join_indexu8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu8($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u16::__pymethod_join_iteru16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru16($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u16::__pymethod_join_indexu16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu16($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u16::__pymethod_join_iteru32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru32($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u16::__pymethod_join_indexu32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu32($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u16::__pymethod_join_iteru64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru64($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u16::__pymethod_join_indexu64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu64($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u16::__pymethod_join_iteru128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru128($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u16::__pymethod_join_indexu128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu128($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                KmerIndex2047u16::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                KmerIndex2047u16::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<KmerIndex2047u16>
                                for PyClassImplCollector<KmerIndex2047u16> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    KmerIndex2047u16::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                KmerIndex2047u16::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex2047u16 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u16::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_build_dna__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u16::build_dna;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build_dna",
                positional_parameter_names: &[
                    "iterator",
                    "index_path",
                    "buffer_size",
                    "index",
                    "modulo",
                ],
                positional_only_parameters: 0usize,
                required_positional_parameters: 5usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 5usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_4 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[3usize].as_deref(),
                            )
                        },
                        &mut holder_3,
                        "index",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[4usize].as_deref(),
                            )
                        },
                        &mut holder_4,
                        "modulo",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_index__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u16::intersection_index;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_index",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_iter__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u16::intersection_iter;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_iter",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_get_all__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u16::get_all;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "get_all",
                positional_parameter_names: &["kmer"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "kmer",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = KmerIndex2047u16::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex2047u16::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex2047u16,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u16::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex2047u16::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex2047u16,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "kmer",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = KmerIndex2047u16::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex2047u16::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<KmerIndex2047u16> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u16::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = KmerIndex2047u16::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<KmerIndex2047u16>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod_size__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u16::size;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function();
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u16::join_iteru8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru8",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u16::join_indexu8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu8",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u16::join_iteru16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru16",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u16::join_indexu16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu16",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u16::join_iteru32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru32",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u16::join_indexu32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu32",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u16::join_iteru64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru64",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u16::join_indexu64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu64",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u16::join_iteru128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru128",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u16::join_indexu128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u16 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu128",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u16,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
    }
    pub struct KmerIndex2047u32(pub KmerIndex<2047, Store2047, u32>);
    #[automatically_derived]
    impl ::core::clone::Clone for KmerIndex2047u32 {
        #[inline]
        fn clone(&self) -> KmerIndex2047u32 {
            KmerIndex2047u32(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for KmerIndex2047u32 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for KmerIndex2047u32 {
        const NAME: &'static str = "KmerIndex2047u32";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <KmerIndex2047u32 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for KmerIndex2047u32 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a KmerIndex2047u32 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, KmerIndex2047u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut KmerIndex2047u32 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, KmerIndex2047u32>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for KmerIndex2047u32 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for KmerIndex2047u32 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<KmerIndex2047u32>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for KmerIndex2047u32 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<KmerIndex2047u32>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<KmerIndex2047u32> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex2047u32 {}
    impl KmerIndex2047u32 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex2047u32 {}
    impl KmerIndex2047u32 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let kmer_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let kmer: PyKmer2047 = base_tuple
                                .get_item(0)?
                                .extract()
                                .unwrap();
                            let val: u32 = base_tuple.get_item(1)?.extract().unwrap();
                            Ok(KmerIndexEntry::<2047, Store2047, u32> {
                                key: kmer.0.into(),
                                val,
                            })
                        })
                });
            Ok(
                Self(
                    KmerIndex::<
                        2047,
                        Store2047,
                        u32,
                    >::build_index(
                            kmer_entry_iter.map(|e| e.unwrap()),
                            path,
                            buffer_size,
                        )
                        .unwrap(),
                ),
            )
        }
        /// Build the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)
        pub fn build_dna(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
            index: u64,
            modulo: u64,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let dna_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let dna: PyDNA = base_tuple.get_item(0)?.extract().unwrap();
                            let val: u32 = base_tuple.get_item(0)?.extract().unwrap();
                            Ok((dna, val))
                        })
                });
            let kmer_iter = dna_entry_iter
                .map(|e| e.unwrap())
                .flat_map(|(dna, val)| {
                    let kmer_it: CanonicalKmerIterator<2047, Store2047> = (&dna.0)
                        .into();
                    let kmer_vec: Vec<KmerIndexEntry<2047, Store2047, u32>> = kmer_it
                        .filter(|kmer| kmer.hash() % modulo == index)
                        .map(move |kmer| KmerIndexEntry::<2047, Store2047, u32> {
                            key: kmer,
                            val,
                        })
                        .collect();
                    kmer_vec.into_iter()
                });
            Ok(
                Self(
                    KmerIndex::<
                        2047,
                        Store2047,
                        u32,
                    >::build_index(kmer_iter, path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn intersection_index(
            &self,
            other: &KmerSet2047,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(IntSetu32(self.0.join_index::<()>(other.0.clone(), path, buffer_size)))
        }
        pub fn intersection_iter(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            Ok((i.extract::<PyKmer2047>().unwrap().0.into(), ()))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntSetu32(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn get_all(&self, kmer: PyKmer2047) -> PyResult<Vec<u32>> {
            match self.0.get_all(kmer.0.into()) {
                Ok(iter) => Ok(iter.collect()),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, kmer: PyKmer2047) -> PyResult<u32> {
            match self.0.get(kmer.0.into()) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(KmerIndex::<2047, Store2047, u32>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIterator2047u32>> {
            let iter = IndexIterator2047u32(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
        fn size() -> PyResult<usize> {
            Ok(2047)
        }
        pub fn join_iteru8(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer2047>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u8>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu32u8(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu8(
            &self,
            other: &KmerIndex2047u8,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu32u8(
                    self.0.join_index::<u8>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru16(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer2047>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u16>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu32u16(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu16(
            &self,
            other: &KmerIndex2047u16,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu32u16(
                    self.0.join_index::<u16>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru32(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer2047>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u32>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu32u32(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu32(
            &self,
            other: &KmerIndex2047u32,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu32u32(
                    self.0.join_index::<u32>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru64(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer2047>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u64>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu32u64(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu64(
            &self,
            other: &KmerIndex2047u64,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu32u64(
                    self.0.join_index::<u64>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru128(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer2047>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u128>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu32u128(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu128(
            &self,
            other: &KmerIndex2047u128,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu32u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu32u128(
                    self.0.join_index::<u128>(other.0.clone(), path, buffer_size),
                ),
            )
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<KmerIndex2047u32>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<KmerIndex2047u32> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex2047u32::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build_dna",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex2047u32::__pymethod_build_dna__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build_dna($cls, iterator, index_path, buffer_size, index, modulo)\n--\n\nBuild the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_index",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u32::__pymethod_intersection_index__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_index($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_iter",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u32::__pymethod_intersection_iter__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_iter($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"get_all",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u32::__pymethod_get_all__,
                                        )
                                    }
                                    trampoline
                                },
                                c"get_all($self, kmer)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Static(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                    c"size",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            unsafe {
                                                ::pyo3::impl_::trampoline::noargs(
                                                    _slf,
                                                    _args,
                                                    KmerIndex2047u32::__pymethod_size__,
                                                )
                                            }
                                        }
                                        trampoline
                                    },
                                    c"size()\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_STATIC),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u32::__pymethod_join_iteru8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru8($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u32::__pymethod_join_indexu8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu8($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u32::__pymethod_join_iteru16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru16($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u32::__pymethod_join_indexu16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu16($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u32::__pymethod_join_iteru32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru32($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u32::__pymethod_join_indexu32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu32($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u32::__pymethod_join_iteru64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru64($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u32::__pymethod_join_indexu64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu64($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u32::__pymethod_join_iteru128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru128($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u32::__pymethod_join_indexu128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu128($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                KmerIndex2047u32::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                KmerIndex2047u32::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<KmerIndex2047u32>
                                for PyClassImplCollector<KmerIndex2047u32> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    KmerIndex2047u32::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                KmerIndex2047u32::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex2047u32 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u32::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_build_dna__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u32::build_dna;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build_dna",
                positional_parameter_names: &[
                    "iterator",
                    "index_path",
                    "buffer_size",
                    "index",
                    "modulo",
                ],
                positional_only_parameters: 0usize,
                required_positional_parameters: 5usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 5usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_4 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[3usize].as_deref(),
                            )
                        },
                        &mut holder_3,
                        "index",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[4usize].as_deref(),
                            )
                        },
                        &mut holder_4,
                        "modulo",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_index__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u32::intersection_index;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_index",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_iter__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u32::intersection_iter;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_iter",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_get_all__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u32::get_all;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "get_all",
                positional_parameter_names: &["kmer"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "kmer",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = KmerIndex2047u32::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex2047u32::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex2047u32,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u32::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex2047u32::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex2047u32,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "kmer",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = KmerIndex2047u32::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex2047u32::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<KmerIndex2047u32> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u32::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = KmerIndex2047u32::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<KmerIndex2047u32>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod_size__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u32::size;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function();
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u32::join_iteru8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru8",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u32::join_indexu8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu8",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u32::join_iteru16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru16",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u32::join_indexu16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu16",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u32::join_iteru32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru32",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u32::join_indexu32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu32",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u32::join_iteru64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru64",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u32::join_indexu64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu64",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u32::join_iteru128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru128",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u32::join_indexu128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u32 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu128",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u32,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
    }
    pub struct KmerIndex2047u64(pub KmerIndex<2047, Store2047, u64>);
    #[automatically_derived]
    impl ::core::clone::Clone for KmerIndex2047u64 {
        #[inline]
        fn clone(&self) -> KmerIndex2047u64 {
            KmerIndex2047u64(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for KmerIndex2047u64 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for KmerIndex2047u64 {
        const NAME: &'static str = "KmerIndex2047u64";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <KmerIndex2047u64 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for KmerIndex2047u64 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a KmerIndex2047u64 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, KmerIndex2047u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut KmerIndex2047u64 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, KmerIndex2047u64>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for KmerIndex2047u64 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for KmerIndex2047u64 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<KmerIndex2047u64>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for KmerIndex2047u64 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<KmerIndex2047u64>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<KmerIndex2047u64> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex2047u64 {}
    impl KmerIndex2047u64 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex2047u64 {}
    impl KmerIndex2047u64 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let kmer_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let kmer: PyKmer2047 = base_tuple
                                .get_item(0)?
                                .extract()
                                .unwrap();
                            let val: u64 = base_tuple.get_item(1)?.extract().unwrap();
                            Ok(KmerIndexEntry::<2047, Store2047, u64> {
                                key: kmer.0.into(),
                                val,
                            })
                        })
                });
            Ok(
                Self(
                    KmerIndex::<
                        2047,
                        Store2047,
                        u64,
                    >::build_index(
                            kmer_entry_iter.map(|e| e.unwrap()),
                            path,
                            buffer_size,
                        )
                        .unwrap(),
                ),
            )
        }
        /// Build the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)
        pub fn build_dna(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
            index: u64,
            modulo: u64,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let dna_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let dna: PyDNA = base_tuple.get_item(0)?.extract().unwrap();
                            let val: u64 = base_tuple.get_item(0)?.extract().unwrap();
                            Ok((dna, val))
                        })
                });
            let kmer_iter = dna_entry_iter
                .map(|e| e.unwrap())
                .flat_map(|(dna, val)| {
                    let kmer_it: CanonicalKmerIterator<2047, Store2047> = (&dna.0)
                        .into();
                    let kmer_vec: Vec<KmerIndexEntry<2047, Store2047, u64>> = kmer_it
                        .filter(|kmer| kmer.hash() % modulo == index)
                        .map(move |kmer| KmerIndexEntry::<2047, Store2047, u64> {
                            key: kmer,
                            val,
                        })
                        .collect();
                    kmer_vec.into_iter()
                });
            Ok(
                Self(
                    KmerIndex::<
                        2047,
                        Store2047,
                        u64,
                    >::build_index(kmer_iter, path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn intersection_index(
            &self,
            other: &KmerSet2047,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(IntSetu64(self.0.join_index::<()>(other.0.clone(), path, buffer_size)))
        }
        pub fn intersection_iter(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            Ok((i.extract::<PyKmer2047>().unwrap().0.into(), ()))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntSetu64(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn get_all(&self, kmer: PyKmer2047) -> PyResult<Vec<u64>> {
            match self.0.get_all(kmer.0.into()) {
                Ok(iter) => Ok(iter.collect()),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, kmer: PyKmer2047) -> PyResult<u64> {
            match self.0.get(kmer.0.into()) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(KmerIndex::<2047, Store2047, u64>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIterator2047u64>> {
            let iter = IndexIterator2047u64(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
        fn size() -> PyResult<usize> {
            Ok(2047)
        }
        pub fn join_iteru8(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer2047>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u8>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu64u8(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu8(
            &self,
            other: &KmerIndex2047u8,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu64u8(
                    self.0.join_index::<u8>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru16(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer2047>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u16>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu64u16(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu16(
            &self,
            other: &KmerIndex2047u16,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu64u16(
                    self.0.join_index::<u16>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru32(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer2047>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u32>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu64u32(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu32(
            &self,
            other: &KmerIndex2047u32,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu64u32(
                    self.0.join_index::<u32>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru64(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer2047>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u64>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu64u64(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu64(
            &self,
            other: &KmerIndex2047u64,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu64u64(
                    self.0.join_index::<u64>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru128(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer2047>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u128>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu64u128(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu128(
            &self,
            other: &KmerIndex2047u128,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu64u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu64u128(
                    self.0.join_index::<u128>(other.0.clone(), path, buffer_size),
                ),
            )
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<KmerIndex2047u64>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<KmerIndex2047u64> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex2047u64::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build_dna",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex2047u64::__pymethod_build_dna__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build_dna($cls, iterator, index_path, buffer_size, index, modulo)\n--\n\nBuild the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_index",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u64::__pymethod_intersection_index__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_index($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_iter",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u64::__pymethod_intersection_iter__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_iter($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"get_all",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u64::__pymethod_get_all__,
                                        )
                                    }
                                    trampoline
                                },
                                c"get_all($self, kmer)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Static(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                    c"size",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            unsafe {
                                                ::pyo3::impl_::trampoline::noargs(
                                                    _slf,
                                                    _args,
                                                    KmerIndex2047u64::__pymethod_size__,
                                                )
                                            }
                                        }
                                        trampoline
                                    },
                                    c"size()\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_STATIC),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u64::__pymethod_join_iteru8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru8($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u64::__pymethod_join_indexu8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu8($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u64::__pymethod_join_iteru16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru16($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u64::__pymethod_join_indexu16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu16($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u64::__pymethod_join_iteru32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru32($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u64::__pymethod_join_indexu32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu32($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u64::__pymethod_join_iteru64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru64($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u64::__pymethod_join_indexu64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu64($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u64::__pymethod_join_iteru128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru128($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u64::__pymethod_join_indexu128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu128($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                KmerIndex2047u64::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                KmerIndex2047u64::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<KmerIndex2047u64>
                                for PyClassImplCollector<KmerIndex2047u64> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    KmerIndex2047u64::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                KmerIndex2047u64::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex2047u64 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u64::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_build_dna__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u64::build_dna;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build_dna",
                positional_parameter_names: &[
                    "iterator",
                    "index_path",
                    "buffer_size",
                    "index",
                    "modulo",
                ],
                positional_only_parameters: 0usize,
                required_positional_parameters: 5usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 5usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_4 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[3usize].as_deref(),
                            )
                        },
                        &mut holder_3,
                        "index",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[4usize].as_deref(),
                            )
                        },
                        &mut holder_4,
                        "modulo",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_index__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u64::intersection_index;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_index",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_iter__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u64::intersection_iter;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_iter",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_get_all__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u64::get_all;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "get_all",
                positional_parameter_names: &["kmer"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "kmer",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = KmerIndex2047u64::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex2047u64::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex2047u64,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u64::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex2047u64::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex2047u64,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "kmer",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = KmerIndex2047u64::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex2047u64::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<KmerIndex2047u64> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u64::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = KmerIndex2047u64::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<KmerIndex2047u64>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod_size__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u64::size;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function();
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u64::join_iteru8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru8",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u64::join_indexu8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu8",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u64::join_iteru16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru16",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u64::join_indexu16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu16",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u64::join_iteru32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru32",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u64::join_indexu32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu32",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u64::join_iteru64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru64",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u64::join_indexu64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu64",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u64::join_iteru128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru128",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u64::join_indexu128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u64 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu128",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u64,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
    }
    pub struct KmerIndex2047u128(pub KmerIndex<2047, Store2047, u128>);
    #[automatically_derived]
    impl ::core::clone::Clone for KmerIndex2047u128 {
        #[inline]
        fn clone(&self) -> KmerIndex2047u128 {
            KmerIndex2047u128(::core::clone::Clone::clone(&self.0))
        }
    }
    impl ::pyo3::types::DerefToPyAny for KmerIndex2047u128 {}
    unsafe impl ::pyo3::type_object::PyTypeInfo for KmerIndex2047u128 {
        const NAME: &'static str = "KmerIndex2047u128";
        const MODULE: ::std::option::Option<&'static str> = ::core::option::Option::None;
        #[inline]
        fn type_object_raw(py: ::pyo3::Python<'_>) -> *mut ::pyo3::ffi::PyTypeObject {
            use ::pyo3::prelude::PyTypeMethods;
            <KmerIndex2047u128 as ::pyo3::impl_::pyclass::PyClassImpl>::lazy_type_object()
                .get_or_init(py)
                .as_type_ptr()
        }
    }
    impl ::pyo3::PyClass for KmerIndex2047u128 {
        type Frozen = ::pyo3::pyclass::boolean_struct::False;
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a KmerIndex2047u128 {
        type Holder = ::std::option::Option<::pyo3::PyRef<'py, KmerIndex2047u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref(obj, holder)
        }
    }
    impl<'a, 'py> ::pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'py>
    for &'a mut KmerIndex2047u128 {
        type Holder = ::std::option::Option<::pyo3::PyRefMut<'py, KmerIndex2047u128>>;
        #[inline]
        fn extract(
            obj: &'a ::pyo3::Bound<'py, ::pyo3::PyAny>,
            holder: &'a mut Self::Holder,
        ) -> ::pyo3::PyResult<Self> {
            ::pyo3::impl_::extract_argument::extract_pyclass_ref_mut(obj, holder)
        }
    }
    #[allow(deprecated)]
    impl ::pyo3::IntoPy<::pyo3::PyObject> for KmerIndex2047u128 {
        fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
            ::pyo3::IntoPy::into_py(::pyo3::Py::new(py, self).unwrap(), py)
        }
    }
    impl<'py> ::pyo3::conversion::IntoPyObject<'py> for KmerIndex2047u128 {
        type Target = Self;
        type Output = ::pyo3::Bound<
            'py,
            <Self as ::pyo3::conversion::IntoPyObject<'py>>::Target,
        >;
        type Error = ::pyo3::PyErr;
        fn into_pyobject(
            self,
            py: ::pyo3::Python<'py>,
        ) -> ::std::result::Result<
            <Self as ::pyo3::conversion::IntoPyObject>::Output,
            <Self as ::pyo3::conversion::IntoPyObject>::Error,
        > {
            ::pyo3::Bound::new(py, self)
        }
    }
    const _: () = {
        ::pyo3::impl_::pyclass::assert_pyclass_sync::<KmerIndex2047u128>();
    };
    impl ::pyo3::impl_::pyclass::PyClassImpl for KmerIndex2047u128 {
        const IS_BASETYPE: bool = false;
        const IS_SUBCLASS: bool = false;
        const IS_MAPPING: bool = false;
        const IS_SEQUENCE: bool = false;
        type BaseType = ::pyo3::PyAny;
        type ThreadChecker = ::pyo3::impl_::pyclass::SendablePyClass<KmerIndex2047u128>;
        type PyClassMutability = <<::pyo3::PyAny as ::pyo3::impl_::pyclass::PyClassBaseType>::PyClassMutability as ::pyo3::impl_::pycell::PyClassMutability>::MutableChild;
        type Dict = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type WeakRef = ::pyo3::impl_::pyclass::PyClassDummySlot;
        type BaseNativeType = ::pyo3::PyAny;
        fn items_iter() -> ::pyo3::impl_::pyclass::PyClassItemsIter {
            use ::pyo3::impl_::pyclass::*;
            let collector = PyClassImplCollector::<Self>::new();
            static INTRINSIC_ITEMS: PyClassItems = PyClassItems {
                methods: &[],
                slots: &[],
            };
            PyClassItemsIter::new(&INTRINSIC_ITEMS, collector.py_methods())
        }
        fn doc(py: ::pyo3::Python<'_>) -> ::pyo3::PyResult<&'static ::std::ffi::CStr> {
            use ::pyo3::impl_::pyclass::*;
            static DOC: ::pyo3::sync::GILOnceCell<
                ::std::borrow::Cow<'static, ::std::ffi::CStr>,
            > = ::pyo3::sync::GILOnceCell::new();
            DOC.get_or_try_init(
                    py,
                    || {
                        let collector = PyClassImplCollector::<Self>::new();
                        build_pyclass_doc(
                            <Self as ::pyo3::PyTypeInfo>::NAME,
                            c"",
                            collector.new_text_signature(),
                        )
                    },
                )
                .map(::std::ops::Deref::deref)
        }
        fn lazy_type_object() -> &'static ::pyo3::impl_::pyclass::LazyTypeObject<Self> {
            use ::pyo3::impl_::pyclass::LazyTypeObject;
            static TYPE_OBJECT: LazyTypeObject<KmerIndex2047u128> = LazyTypeObject::new();
            &TYPE_OBJECT
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex2047u128 {}
    impl KmerIndex2047u128 {
        #[doc(hidden)]
        pub const _PYO3_DEF: ::pyo3::impl_::pymodule::AddClassToModule<Self> = ::pyo3::impl_::pymodule::AddClassToModule::new();
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex2047u128 {}
    impl KmerIndex2047u128 {
        pub fn build(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let kmer_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let kmer: PyKmer2047 = base_tuple
                                .get_item(0)?
                                .extract()
                                .unwrap();
                            let val: u128 = base_tuple.get_item(1)?.extract().unwrap();
                            Ok(KmerIndexEntry::<2047, Store2047, u128> {
                                key: kmer.0.into(),
                                val,
                            })
                        })
                });
            Ok(
                Self(
                    KmerIndex::<
                        2047,
                        Store2047,
                        u128,
                    >::build_index(
                            kmer_entry_iter.map(|e| e.unwrap()),
                            path,
                            buffer_size,
                        )
                        .unwrap(),
                ),
            )
        }
        /// Build the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)
        pub fn build_dna(
            _: &Bound<'_, PyType>,
            iterator: &Bound<'_, PyIterator>,
            index_path: &Bound<'_, PyString>,
            buffer_size: usize,
            index: u64,
            modulo: u64,
        ) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            let dna_entry_iter = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            let dna: PyDNA = base_tuple.get_item(0)?.extract().unwrap();
                            let val: u128 = base_tuple.get_item(0)?.extract().unwrap();
                            Ok((dna, val))
                        })
                });
            let kmer_iter = dna_entry_iter
                .map(|e| e.unwrap())
                .flat_map(|(dna, val)| {
                    let kmer_it: CanonicalKmerIterator<2047, Store2047> = (&dna.0)
                        .into();
                    let kmer_vec: Vec<KmerIndexEntry<2047, Store2047, u128>> = kmer_it
                        .filter(|kmer| kmer.hash() % modulo == index)
                        .map(move |kmer| KmerIndexEntry::<2047, Store2047, u128> {
                            key: kmer,
                            val,
                        })
                        .collect();
                    kmer_vec.into_iter()
                });
            Ok(
                Self(
                    KmerIndex::<
                        2047,
                        Store2047,
                        u128,
                    >::build_index(kmer_iter, path, buffer_size)
                        .unwrap(),
                ),
            )
        }
        pub fn intersection_index(
            &self,
            other: &KmerSet2047,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(IntSetu128(self.0.join_index::<()>(other.0.clone(), path, buffer_size)))
        }
        pub fn intersection_iter(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntSetu128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            Ok((i.extract::<PyKmer2047>().unwrap().0.into(), ()))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntSetu128(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn get_all(&self, kmer: PyKmer2047) -> PyResult<Vec<u128>> {
            match self.0.get_all(kmer.0.into()) {
                Ok(iter) => Ok(iter.collect()),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        pub fn __len__(&self) -> PyResult<usize> {
            Ok(self.0.len())
        }
        pub fn __getitem__(&self, kmer: PyKmer2047) -> PyResult<u128> {
            match self.0.get(kmer.0.into()) {
                Ok(val) => Ok(val),
                _ => Err(PyKeyError::new_err(kmer)),
            }
        }
        fn new(index_path: &Bound<'_, PyString>) -> PyResult<Self> {
            let path: &Path = Path::new(index_path.to_str()?);
            Ok(Self(KmerIndex::<2047, Store2047, u128>::load_index(path).unwrap()))
        }
        fn __iter__(slf: PyRef<Self>) -> PyResult<Py<IndexIterator2047u128>> {
            let iter = IndexIterator2047u128(slf.0.clone().into_iter());
            Py::new(slf.py(), iter)
        }
        fn size() -> PyResult<usize> {
            Ok(2047)
        }
        pub fn join_iteru8(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer2047>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u8>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu128u8(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu8(
            &self,
            other: &KmerIndex2047u8,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u8> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu128u8(
                    self.0.join_index::<u8>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru16(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer2047>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u16>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu128u16(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu16(
            &self,
            other: &KmerIndex2047u16,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u16> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu128u16(
                    self.0.join_index::<u16>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru32(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer2047>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u32>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu128u32(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu32(
            &self,
            other: &KmerIndex2047u32,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u32> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu128u32(
                    self.0.join_index::<u32>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru64(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer2047>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u64>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu128u64(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu64(
            &self,
            other: &KmerIndex2047u64,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u64> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu128u64(
                    self.0.join_index::<u64>(other.0.clone(), path, buffer_size),
                ),
            )
        }
        pub fn join_iteru128(
            &self,
            iterator: &Bound<'_, PyIterator>,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            let parsed_iterator = iterator
                .try_iter()?
                .map(|i| {
                    i
                        .and_then(|i| {
                            let base_tuple = i.downcast::<PyTuple>().unwrap();
                            Ok((
                                base_tuple
                                    .get_item(0)?
                                    .extract::<PyKmer2047>()
                                    .unwrap()
                                    .0
                                    .into(),
                                base_tuple.get_item(1)?.extract::<u128>().unwrap(),
                            ))
                        })
                })
                .map(|e| e.unwrap());
            Ok(IntIndexu128u128(self.0.join_iter(parsed_iterator, path, buffer_size)))
        }
        pub fn join_indexu128(
            &self,
            other: &KmerIndex2047u128,
            out_path: &Bound<'_, PyString>,
            buffer_size: usize,
        ) -> PyResult<IntIndexu128u128> {
            let path: &Path = Path::new(out_path.to_str().unwrap());
            Ok(
                IntIndexu128u128(
                    self.0.join_index::<u128>(other.0.clone(), path, buffer_size),
                ),
            )
        }
    }
    #[allow(unknown_lints, non_local_definitions)]
    impl ::pyo3::impl_::pyclass::PyMethods<KmerIndex2047u128>
    for ::pyo3::impl_::pyclass::PyClassImplCollector<KmerIndex2047u128> {
        fn py_methods(self) -> &'static ::pyo3::impl_::pyclass::PyClassItems {
            static ITEMS: ::pyo3::impl_::pyclass::PyClassItems = ::pyo3::impl_::pyclass::PyClassItems {
                methods: &[
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex2047u128::__pymethod_build__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build($cls, iterator, index_path, buffer_size)\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Class(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                    c"build_dna",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *const *mut ::pyo3::ffi::PyObject,
                                            _nargs: ::pyo3::ffi::Py_ssize_t,
                                            _kwnames: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                                _slf,
                                                _args,
                                                _nargs,
                                                _kwnames,
                                                KmerIndex2047u128::__pymethod_build_dna__,
                                            )
                                        }
                                        trampoline
                                    },
                                    c"build_dna($cls, iterator, index_path, buffer_size, index, modulo)\n--\n\nBuild the shard by keeping only kmer satisfying (kmer.hash() % modulo == index)",
                                )
                                .flags(::pyo3::ffi::METH_CLASS),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_index",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u128::__pymethod_intersection_index__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_index($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"intersection_iter",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u128::__pymethod_intersection_iter__,
                                        )
                                    }
                                    trampoline
                                },
                                c"intersection_iter($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"get_all",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u128::__pymethod_get_all__,
                                        )
                                    }
                                    trampoline
                                },
                                c"get_all($self, kmer)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Static(
                            ::pyo3::impl_::pymethods::PyMethodDef::noargs(
                                    c"size",
                                    {
                                        unsafe extern "C" fn trampoline(
                                            _slf: *mut ::pyo3::ffi::PyObject,
                                            _args: *mut ::pyo3::ffi::PyObject,
                                        ) -> *mut ::pyo3::ffi::PyObject {
                                            unsafe {
                                                ::pyo3::impl_::trampoline::noargs(
                                                    _slf,
                                                    _args,
                                                    KmerIndex2047u128::__pymethod_size__,
                                                )
                                            }
                                        }
                                        trampoline
                                    },
                                    c"size()\n--\n\n",
                                )
                                .flags(::pyo3::ffi::METH_STATIC),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u128::__pymethod_join_iteru8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru8($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu8",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u128::__pymethod_join_indexu8__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu8($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u128::__pymethod_join_iteru16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru16($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu16",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u128::__pymethod_join_indexu16__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu16($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u128::__pymethod_join_iteru32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru32($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu32",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u128::__pymethod_join_indexu32__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu32($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u128::__pymethod_join_iteru64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru64($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu64",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u128::__pymethod_join_indexu64__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu64($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_iteru128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u128::__pymethod_join_iteru128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_iteru128($self, iterator, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                    ::pyo3::impl_::pyclass::MaybeRuntimePyMethodDef::Static(
                        ::pyo3::impl_::pymethods::PyMethodDefType::Method(
                            ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
                                c"join_indexu128",
                                {
                                    unsafe extern "C" fn trampoline(
                                        _slf: *mut ::pyo3::ffi::PyObject,
                                        _args: *const *mut ::pyo3::ffi::PyObject,
                                        _nargs: ::pyo3::ffi::Py_ssize_t,
                                        _kwnames: *mut ::pyo3::ffi::PyObject,
                                    ) -> *mut ::pyo3::ffi::PyObject {
                                        ::pyo3::impl_::trampoline::fastcall_with_keywords(
                                            _slf,
                                            _args,
                                            _nargs,
                                            _kwnames,
                                            KmerIndex2047u128::__pymethod_join_indexu128__,
                                        )
                                    }
                                    trampoline
                                },
                                c"join_indexu128($self, other, out_path, buffer_size)\n--\n\n",
                            ),
                        ),
                    ),
                ],
                slots: &[
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> ::pyo3::ffi::Py_ssize_t {
                            ::pyo3::impl_::trampoline::lenfunc(
                                _slf,
                                KmerIndex2047u128::__pymethod___len____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_length,
                            pfunc: trampoline as ::pyo3::ffi::lenfunc as _,
                        }
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                            arg0: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::binaryfunc(
                                _slf,
                                arg0,
                                KmerIndex2047u128::__pymethod___getitem____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_mp_subscript,
                            pfunc: trampoline as ::pyo3::ffi::binaryfunc as _,
                        }
                    },
                    ::pyo3::ffi::PyType_Slot {
                        slot: ::pyo3::ffi::Py_tp_new,
                        pfunc: {
                            unsafe extern "C" fn trampoline(
                                subtype: *mut ::pyo3::ffi::PyTypeObject,
                                args: *mut ::pyo3::ffi::PyObject,
                                kwargs: *mut ::pyo3::ffi::PyObject,
                            ) -> *mut ::pyo3::ffi::PyObject {
                                use ::pyo3::impl_::pyclass::*;
                                #[allow(unknown_lints, non_local_definitions)]
                                impl PyClassNewTextSignature<KmerIndex2047u128>
                                for PyClassImplCollector<KmerIndex2047u128> {
                                    #[inline]
                                    fn new_text_signature(
                                        self,
                                    ) -> ::std::option::Option<&'static str> {
                                        ::std::option::Option::Some("(index_path)")
                                    }
                                }
                                ::pyo3::impl_::trampoline::newfunc(
                                    subtype,
                                    args,
                                    kwargs,
                                    KmerIndex2047u128::__pymethod___new____,
                                )
                            }
                            trampoline
                        } as ::pyo3::ffi::newfunc as _,
                    },
                    {
                        unsafe extern "C" fn trampoline(
                            _slf: *mut ::pyo3::ffi::PyObject,
                        ) -> *mut ::pyo3::ffi::PyObject {
                            ::pyo3::impl_::trampoline::getiterfunc(
                                _slf,
                                KmerIndex2047u128::__pymethod___iter____,
                            )
                        }
                        ::pyo3::ffi::PyType_Slot {
                            slot: ::pyo3::ffi::Py_tp_iter,
                            pfunc: trampoline as ::pyo3::ffi::getiterfunc as _,
                        }
                    },
                ],
            };
            &ITEMS
        }
    }
    #[doc(hidden)]
    #[allow(non_snake_case)]
    impl KmerIndex2047u128 {
        unsafe fn __pymethod_build__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u128::build;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build",
                positional_parameter_names: &["iterator", "index_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_build_dna__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u128::build_dna;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "build_dna",
                positional_parameter_names: &[
                    "iterator",
                    "index_path",
                    "buffer_size",
                    "index",
                    "modulo",
                ],
                positional_only_parameters: 0usize,
                required_positional_parameters: 5usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 5usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_4 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    unsafe {
                        #[allow(clippy::useless_conversion)]
                        ::std::convert::Into::into(
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(
                                    py,
                                    &*(&_slf as *const _ as *const *mut _),
                                )
                                .downcast_unchecked::<::pyo3::types::PyType>(),
                        )
                    },
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "index_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[3usize].as_deref(),
                            )
                        },
                        &mut holder_3,
                        "index",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[4usize].as_deref(),
                            )
                        },
                        &mut holder_4,
                        "modulo",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_index__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u128::intersection_index;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_index",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_intersection_iter__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u128::intersection_iter;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "intersection_iter",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_get_all__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u128::get_all;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "get_all",
                positional_parameter_names: &["kmer"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_1,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "kmer",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___len____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<::pyo3::ffi::Py_ssize_t> {
            let function = KmerIndex2047u128::__len__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex2047u128::__len__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex2047u128,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___getitem____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
            arg0: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u128::__getitem__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex2047u128::__getitem__(
                ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                    KmerIndex2047u128,
                >(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                    }
                        .0,
                    &mut holder_0,
                )?,
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &arg0).0
                    },
                    &mut holder_1,
                    "kmer",
                )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod___new____(
            py: ::pyo3::Python<'_>,
            _slf: *mut ::pyo3::ffi::PyTypeObject,
            _args: *mut ::pyo3::ffi::PyObject,
            _kwargs: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            use ::pyo3::impl_::callback::IntoPyCallbackOutput;
            let function = KmerIndex2047u128::new;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "__new__",
                positional_parameter_names: &["index_path"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 1usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 1usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_tuple_dict::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _kwargs, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = KmerIndex2047u128::new(
                ::pyo3::impl_::extract_argument::extract_argument(
                    unsafe {
                        ::pyo3::impl_::extract_argument::unwrap_required_argument(
                            output[0usize].as_deref(),
                        )
                    },
                    &mut holder_0,
                    "index_path",
                )?,
            );
            let initializer: ::pyo3::PyClassInitializer<KmerIndex2047u128> = result
                .convert(py)?;
            ::pyo3::impl_::pymethods::tp_new_impl(py, initializer, _slf)
        }
        #[allow(non_snake_case)]
        unsafe fn __pymethod___iter____(
            py: ::pyo3::Python<'_>,
            _raw_slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u128::__iter__;
            let _slf = _raw_slf;
            #[allow(clippy::let_unit_value)]
            let result = KmerIndex2047u128::__iter__(
                unsafe { ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf) }
                    .downcast::<KmerIndex2047u128>()
                    .map_err(::std::convert::Into::<::pyo3::PyErr>::into)
                    .and_then(
                        #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]
                        |bound| {
                            ::std::convert::TryFrom::try_from(bound)
                                .map_err(::std::convert::Into::into)
                        },
                    )?,
            );
            ::pyo3::impl_::callback::convert(py, result)
        }
        unsafe fn __pymethod_size__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u128::size;
            #[allow(clippy::let_unit_value)]
            let result = {
                let ret = function();
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u128::join_iteru8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru8",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu8__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u128::join_indexu8;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu8",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u128::join_iteru16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru16",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu16__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u128::join_indexu16;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu16",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u128::join_iteru32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru32",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu32__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u128::join_indexu32;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu32",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u128::join_iteru64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru64",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu64__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u128::join_indexu64;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu64",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_iteru128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u128::join_iteru128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_iteru128",
                positional_parameter_names: &["iterator", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "iterator",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
        unsafe fn __pymethod_join_indexu128__<'py>(
            py: ::pyo3::Python<'py>,
            _slf: *mut ::pyo3::ffi::PyObject,
            _args: *const *mut ::pyo3::ffi::PyObject,
            _nargs: ::pyo3::ffi::Py_ssize_t,
            _kwnames: *mut ::pyo3::ffi::PyObject,
        ) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
            let function = KmerIndex2047u128::join_indexu128;
            const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
                cls_name: ::std::option::Option::Some(
                    <KmerIndex2047u128 as ::pyo3::type_object::PyTypeInfo>::NAME,
                ),
                func_name: "join_indexu128",
                positional_parameter_names: &["other", "out_path", "buffer_size"],
                positional_only_parameters: 0usize,
                required_positional_parameters: 3usize,
                keyword_only_parameters: &[],
            };
            let mut output = [::std::option::Option::None; 3usize];
            let (_args, _kwargs) = DESCRIPTION
                .extract_arguments_fastcall::<
                    ::pyo3::impl_::extract_argument::NoVarargs,
                    ::pyo3::impl_::extract_argument::NoVarkeywords,
                >(py, _args, _nargs, _kwnames, &mut output)?;
            #[allow(clippy::let_unit_value)]
            let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_1 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_2 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let mut holder_3 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
            let result = {
                let ret = function(
                    ::pyo3::impl_::extract_argument::extract_pyclass_ref::<
                        KmerIndex2047u128,
                    >(
                        unsafe {
                            ::pyo3::impl_::pymethods::BoundRef::ref_from_ptr(py, &_slf)
                        }
                            .0,
                        &mut holder_3,
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[0usize].as_deref(),
                            )
                        },
                        &mut holder_0,
                        "other",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[1usize].as_deref(),
                            )
                        },
                        &mut holder_1,
                        "out_path",
                    )?,
                    ::pyo3::impl_::extract_argument::extract_argument(
                        unsafe {
                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
                                output[2usize].as_deref(),
                            )
                        },
                        &mut holder_2,
                        "buffer_size",
                    )?,
                );
                {
                    let result = {
                        let obj = ret;
                        #[allow(clippy::useless_conversion)]
                        ::pyo3::impl_::wrap::converter(&obj)
                            .wrap(obj)
                            .map_err(::core::convert::Into::<::pyo3::PyErr>::into)
                    };
                    ::pyo3::impl_::wrap::converter(&result).map_into_ptr(py, result)
                }
            };
            result
        }
    }
    m.add_class::<PyKmer2047>()?;
    m.add_class::<KmerSet2047>()?;
    m.add_class::<KmerIndex2047u8>()?;
    m.add_class::<KmerIndex2047u16>()?;
    m.add_class::<KmerIndex2047u32>()?;
    m.add_class::<KmerIndex2047u64>()?;
    m.add_class::<KmerIndex2047u128>()?;
    Ok(())
}
fn base_module(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
    m.add_class::<pydna::PyDNA>()?;
    m.add_class::<pydna::PyNucleotid>()?;
    base_kmer(_py, m).unwrap();
    m.add_class::<pyindex::IntIndexu32u8>()?;
    m.add_class::<pyindex::IntIndexu32u32>()?;
    m.add_class::<pyindex::IntIndexu32u16>()?;
    m.add_class::<pyindex::IntIndexu32u128>()?;
    m.add_class::<pyindex::IntIndexu64u8>()?;
    m.add_class::<pyindex::IntIndexu64u32>()?;
    m.add_class::<pyindex::IntIndexu64u16>()?;
    m.add_class::<pyindex::IntIndexu64u128>()?;
    m.add_class::<pyindex::IntIndexu64u128>()?;
    m.add_class::<pyindex::IntIndexu128u8>()?;
    m.add_class::<pyindex::IntIndexu128u32>()?;
    m.add_class::<pyindex::IntIndexu128u16>()?;
    m.add_class::<pyindex::IntIndexu128u128>()?;
    m.add_class::<pyindex::IntIndexu128u128>()?;
    m.add_class::<pyindex::IntSetu128>()?;
    m.add_class::<pyindex::IntSetu64>()?;
    m.add_class::<pyindex::IntSetu32>()?;
    Ok(())
}
#[target_feature(enable = "avx512vl")]
unsafe fn _vizibridge_avx512vl(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
    base_module(_py, m)
}
#[target_feature(enable = "avx2")]
unsafe fn _vizibridge_avx2(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
    base_module(_py, m)
}
#[target_feature(enable = "sse3")]
unsafe fn _vizibridge_sse3(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
    base_module(_py, m)
}
fn _vizibridge(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
    unsafe {
        if env::var("VIZIBRIDGE_AVX512_ENABLE").is_ok()
            && (true || ::std_detect::detect::__is_feature_detected::avx512vl())
        {
            if env::var("VIZIBRIDGE_INFO").is_ok() {
                {
                    ::std::io::_print(format_args!("WARNING, using AVX512VL\n"));
                };
            }
            return _vizibridge_avx512vl(_py, m);
        }
        if env::var("VIZIBRIDGE_AVX2_DISABLE").is_err()
            && (true || ::std_detect::detect::__is_feature_detected::avx2())
        {
            if env::var("VIZIBRIDGE_INFO").is_ok() {
                {
                    ::std::io::_print(format_args!("WARNING, using AVX2\n"));
                };
            }
            return _vizibridge_avx2(_py, m);
        }
        if env::var("VIZIBRIDGE_SSE3_DISABLE").is_err()
            && (true || ::std_detect::detect::__is_feature_detected::sse3())
        {
            if env::var("VIZIBRIDGE_INFO").is_ok() {
                {
                    ::std::io::_print(format_args!("WARNING, using SSE\n"));
                };
            }
            return _vizibridge_sse3(_py, m);
        }
    }
    base_module(_py, m)
}
#[doc(hidden)]
mod _vizibridge {
    #[doc(hidden)]
    pub const __PYO3_NAME: &'static ::std::ffi::CStr = c"_vizibridge";
    pub(super) struct MakeDef;
    #[doc(hidden)]
    pub static _PYO3_DEF: ::pyo3::impl_::pymodule::ModuleDef = MakeDef::make_def();
    #[doc(hidden)]
    pub static __PYO3_GIL_USED: bool = true;
    /// This autogenerated function is called by the python interpreter when importing
    /// the module.
    #[doc(hidden)]
    #[export_name = "PyInit__vizibridge"]
    pub unsafe extern "C" fn __pyo3_init() -> *mut ::pyo3::ffi::PyObject {
        unsafe {
            ::pyo3::impl_::trampoline::module_init(|py| _PYO3_DEF.make_module(py, true))
        }
    }
}
#[allow(unknown_lints, non_local_definitions)]
impl _vizibridge::MakeDef {
    const fn make_def() -> ::pyo3::impl_::pymodule::ModuleDef {
        fn __pyo3_pymodule(
            module: &::pyo3::Bound<'_, ::pyo3::types::PyModule>,
        ) -> ::pyo3::PyResult<()> {
            _vizibridge(
                module.py(),
                ::std::convert::Into::into(::pyo3::impl_::pymethods::BoundRef(module)),
            )
        }
        const INITIALIZER: ::pyo3::impl_::pymodule::ModuleInitializer = ::pyo3::impl_::pymodule::ModuleInitializer(
            __pyo3_pymodule,
        );
        unsafe {
            ::pyo3::impl_::pymodule::ModuleDef::new(
                _vizibridge::__PYO3_NAME,
                c"",
                INITIALIZER,
            )
        }
    }
}
