# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _cstl
else:
    import _cstl

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


class SwigPyIterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _cstl.delete_SwigPyIterator

    def value(self) -> "PyObject *":
        return _cstl.SwigPyIterator_value(self)

    def incr(self, n: "size_t"=1) -> "swig::SwigPyIterator *":
        return _cstl.SwigPyIterator_incr(self, n)

    def decr(self, n: "size_t"=1) -> "swig::SwigPyIterator *":
        return _cstl.SwigPyIterator_decr(self, n)

    def distance(self, x: "SwigPyIterator") -> "ptrdiff_t":
        return _cstl.SwigPyIterator_distance(self, x)

    def equal(self, x: "SwigPyIterator") -> "bool":
        return _cstl.SwigPyIterator_equal(self, x)

    def copy(self) -> "swig::SwigPyIterator *":
        return _cstl.SwigPyIterator_copy(self)

    def next(self) -> "PyObject *":
        return _cstl.SwigPyIterator_next(self)

    def __next__(self) -> "PyObject *":
        return _cstl.SwigPyIterator___next__(self)

    def previous(self) -> "PyObject *":
        return _cstl.SwigPyIterator_previous(self)

    def advance(self, n: "ptrdiff_t") -> "swig::SwigPyIterator *":
        return _cstl.SwigPyIterator_advance(self, n)

    def __eq__(self, x: "SwigPyIterator") -> "bool":
        return _cstl.SwigPyIterator___eq__(self, x)

    def __ne__(self, x: "SwigPyIterator") -> "bool":
        return _cstl.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator &":
        return _cstl.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator &":
        return _cstl.SwigPyIterator___isub__(self, n)

    def __add__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator *":
        return _cstl.SwigPyIterator___add__(self, n)

    def __sub__(self, *args) -> "ptrdiff_t":
        return _cstl.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _cstl:
_cstl.SwigPyIterator_swigregister(SwigPyIterator)

class VecInt(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecInt___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecInt___bool__(self)

    def __len__(self) -> "std::vector< int >::size_type":
        return _cstl.VecInt___len__(self)

    def __getslice__(self, i: "std::vector< int >::difference_type", j: "std::vector< int >::difference_type") -> "std::vector< int,std::allocator< int > > *":
        return _cstl.VecInt___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecInt___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< int >::difference_type", j: "std::vector< int >::difference_type") -> "void":
        return _cstl.VecInt___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecInt___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< int >::value_type const &":
        return _cstl.VecInt___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecInt___setitem__(self, *args)

    def pop(self) -> "std::vector< int >::value_type":
        return _cstl.VecInt_pop(self)

    def append(self, x: "std::vector< int >::value_type const &") -> "void":
        return _cstl.VecInt_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecInt_empty(self)

    def size(self) -> "std::vector< int >::size_type":
        return _cstl.VecInt_size(self)

    def swap(self, v: "VecInt") -> "void":
        return _cstl.VecInt_swap(self, v)

    def begin(self) -> "std::vector< int >::iterator":
        return _cstl.VecInt_begin(self)

    def end(self) -> "std::vector< int >::iterator":
        return _cstl.VecInt_end(self)

    def rbegin(self) -> "std::vector< int >::reverse_iterator":
        return _cstl.VecInt_rbegin(self)

    def rend(self) -> "std::vector< int >::reverse_iterator":
        return _cstl.VecInt_rend(self)

    def clear(self) -> "void":
        return _cstl.VecInt_clear(self)

    def get_allocator(self) -> "std::vector< int >::allocator_type":
        return _cstl.VecInt_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecInt_pop_back(self)

    def erase(self, *args) -> "std::vector< int >::iterator":
        return _cstl.VecInt_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecInt_swiginit(self, _cstl.new_VecInt(*args))

    def push_back(self, x: "std::vector< int >::value_type const &") -> "void":
        return _cstl.VecInt_push_back(self, x)

    def front(self) -> "std::vector< int >::value_type const &":
        return _cstl.VecInt_front(self)

    def back(self) -> "std::vector< int >::value_type const &":
        return _cstl.VecInt_back(self)

    def assign(self, n: "std::vector< int >::size_type", x: "std::vector< int >::value_type const &") -> "void":
        return _cstl.VecInt_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecInt_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecInt_insert(self, *args)

    def reserve(self, n: "std::vector< int >::size_type") -> "void":
        return _cstl.VecInt_reserve(self, n)

    def capacity(self) -> "std::vector< int >::size_type":
        return _cstl.VecInt_capacity(self)
    __swig_destroy__ = _cstl.delete_VecInt

# Register VecInt in _cstl:
_cstl.VecInt_swigregister(VecInt)

class VecStr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecStr_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecStr___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecStr___bool__(self)

    def __len__(self) -> "std::vector< std::string >::size_type":
        return _cstl.VecStr___len__(self)

    def __getslice__(self, i: "std::vector< std::string >::difference_type", j: "std::vector< std::string >::difference_type") -> "std::vector< std::string,std::allocator< std::string > > *":
        return _cstl.VecStr___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecStr___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::string >::difference_type", j: "std::vector< std::string >::difference_type") -> "void":
        return _cstl.VecStr___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecStr___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::string >::value_type const &":
        return _cstl.VecStr___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecStr___setitem__(self, *args)

    def pop(self) -> "std::vector< std::string >::value_type":
        return _cstl.VecStr_pop(self)

    def append(self, x: "std::vector< std::string >::value_type const &") -> "void":
        return _cstl.VecStr_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecStr_empty(self)

    def size(self) -> "std::vector< std::string >::size_type":
        return _cstl.VecStr_size(self)

    def swap(self, v: "VecStr") -> "void":
        return _cstl.VecStr_swap(self, v)

    def begin(self) -> "std::vector< std::string >::iterator":
        return _cstl.VecStr_begin(self)

    def end(self) -> "std::vector< std::string >::iterator":
        return _cstl.VecStr_end(self)

    def rbegin(self) -> "std::vector< std::string >::reverse_iterator":
        return _cstl.VecStr_rbegin(self)

    def rend(self) -> "std::vector< std::string >::reverse_iterator":
        return _cstl.VecStr_rend(self)

    def clear(self) -> "void":
        return _cstl.VecStr_clear(self)

    def get_allocator(self) -> "std::vector< std::string >::allocator_type":
        return _cstl.VecStr_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecStr_pop_back(self)

    def erase(self, *args) -> "std::vector< std::string >::iterator":
        return _cstl.VecStr_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecStr_swiginit(self, _cstl.new_VecStr(*args))

    def push_back(self, x: "std::vector< std::string >::value_type const &") -> "void":
        return _cstl.VecStr_push_back(self, x)

    def front(self) -> "std::vector< std::string >::value_type const &":
        return _cstl.VecStr_front(self)

    def back(self) -> "std::vector< std::string >::value_type const &":
        return _cstl.VecStr_back(self)

    def assign(self, n: "std::vector< std::string >::size_type", x: "std::vector< std::string >::value_type const &") -> "void":
        return _cstl.VecStr_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecStr_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecStr_insert(self, *args)

    def reserve(self, n: "std::vector< std::string >::size_type") -> "void":
        return _cstl.VecStr_reserve(self, n)

    def capacity(self) -> "std::vector< std::string >::size_type":
        return _cstl.VecStr_capacity(self)
    __swig_destroy__ = _cstl.delete_VecStr

# Register VecStr in _cstl:
_cstl.VecStr_swigregister(VecStr)

class VecFloat(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecFloat_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecFloat___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecFloat___bool__(self)

    def __len__(self) -> "std::vector< float >::size_type":
        return _cstl.VecFloat___len__(self)

    def __getslice__(self, i: "std::vector< float >::difference_type", j: "std::vector< float >::difference_type") -> "std::vector< float,std::allocator< float > > *":
        return _cstl.VecFloat___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecFloat___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< float >::difference_type", j: "std::vector< float >::difference_type") -> "void":
        return _cstl.VecFloat___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecFloat___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< float >::value_type const &":
        return _cstl.VecFloat___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecFloat___setitem__(self, *args)

    def pop(self) -> "std::vector< float >::value_type":
        return _cstl.VecFloat_pop(self)

    def append(self, x: "std::vector< float >::value_type const &") -> "void":
        return _cstl.VecFloat_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecFloat_empty(self)

    def size(self) -> "std::vector< float >::size_type":
        return _cstl.VecFloat_size(self)

    def swap(self, v: "VecFloat") -> "void":
        return _cstl.VecFloat_swap(self, v)

    def begin(self) -> "std::vector< float >::iterator":
        return _cstl.VecFloat_begin(self)

    def end(self) -> "std::vector< float >::iterator":
        return _cstl.VecFloat_end(self)

    def rbegin(self) -> "std::vector< float >::reverse_iterator":
        return _cstl.VecFloat_rbegin(self)

    def rend(self) -> "std::vector< float >::reverse_iterator":
        return _cstl.VecFloat_rend(self)

    def clear(self) -> "void":
        return _cstl.VecFloat_clear(self)

    def get_allocator(self) -> "std::vector< float >::allocator_type":
        return _cstl.VecFloat_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecFloat_pop_back(self)

    def erase(self, *args) -> "std::vector< float >::iterator":
        return _cstl.VecFloat_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecFloat_swiginit(self, _cstl.new_VecFloat(*args))

    def push_back(self, x: "std::vector< float >::value_type const &") -> "void":
        return _cstl.VecFloat_push_back(self, x)

    def front(self) -> "std::vector< float >::value_type const &":
        return _cstl.VecFloat_front(self)

    def back(self) -> "std::vector< float >::value_type const &":
        return _cstl.VecFloat_back(self)

    def assign(self, n: "std::vector< float >::size_type", x: "std::vector< float >::value_type const &") -> "void":
        return _cstl.VecFloat_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecFloat_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecFloat_insert(self, *args)

    def reserve(self, n: "std::vector< float >::size_type") -> "void":
        return _cstl.VecFloat_reserve(self, n)

    def capacity(self) -> "std::vector< float >::size_type":
        return _cstl.VecFloat_capacity(self)
    __swig_destroy__ = _cstl.delete_VecFloat

# Register VecFloat in _cstl:
_cstl.VecFloat_swigregister(VecFloat)

class VecDouble(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecDouble_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecDouble___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecDouble___bool__(self)

    def __len__(self) -> "std::vector< double >::size_type":
        return _cstl.VecDouble___len__(self)

    def __getslice__(self, i: "std::vector< double >::difference_type", j: "std::vector< double >::difference_type") -> "std::vector< double,std::allocator< double > > *":
        return _cstl.VecDouble___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecDouble___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< double >::difference_type", j: "std::vector< double >::difference_type") -> "void":
        return _cstl.VecDouble___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecDouble___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< double >::value_type const &":
        return _cstl.VecDouble___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecDouble___setitem__(self, *args)

    def pop(self) -> "std::vector< double >::value_type":
        return _cstl.VecDouble_pop(self)

    def append(self, x: "std::vector< double >::value_type const &") -> "void":
        return _cstl.VecDouble_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecDouble_empty(self)

    def size(self) -> "std::vector< double >::size_type":
        return _cstl.VecDouble_size(self)

    def swap(self, v: "VecDouble") -> "void":
        return _cstl.VecDouble_swap(self, v)

    def begin(self) -> "std::vector< double >::iterator":
        return _cstl.VecDouble_begin(self)

    def end(self) -> "std::vector< double >::iterator":
        return _cstl.VecDouble_end(self)

    def rbegin(self) -> "std::vector< double >::reverse_iterator":
        return _cstl.VecDouble_rbegin(self)

    def rend(self) -> "std::vector< double >::reverse_iterator":
        return _cstl.VecDouble_rend(self)

    def clear(self) -> "void":
        return _cstl.VecDouble_clear(self)

    def get_allocator(self) -> "std::vector< double >::allocator_type":
        return _cstl.VecDouble_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecDouble_pop_back(self)

    def erase(self, *args) -> "std::vector< double >::iterator":
        return _cstl.VecDouble_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecDouble_swiginit(self, _cstl.new_VecDouble(*args))

    def push_back(self, x: "std::vector< double >::value_type const &") -> "void":
        return _cstl.VecDouble_push_back(self, x)

    def front(self) -> "std::vector< double >::value_type const &":
        return _cstl.VecDouble_front(self)

    def back(self) -> "std::vector< double >::value_type const &":
        return _cstl.VecDouble_back(self)

    def assign(self, n: "std::vector< double >::size_type", x: "std::vector< double >::value_type const &") -> "void":
        return _cstl.VecDouble_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecDouble_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecDouble_insert(self, *args)

    def reserve(self, n: "std::vector< double >::size_type") -> "void":
        return _cstl.VecDouble_reserve(self, n)

    def capacity(self) -> "std::vector< double >::size_type":
        return _cstl.VecDouble_capacity(self)
    __swig_destroy__ = _cstl.delete_VecDouble

# Register VecDouble in _cstl:
_cstl.VecDouble_swigregister(VecDouble)

class VecBool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecBool_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecBool___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecBool___bool__(self)

    def __len__(self) -> "std::vector< bool >::size_type":
        return _cstl.VecBool___len__(self)

    def __getslice__(self, i: "std::vector< bool >::difference_type", j: "std::vector< bool >::difference_type") -> "std::vector< bool,std::allocator< bool > > *":
        return _cstl.VecBool___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecBool___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< bool >::difference_type", j: "std::vector< bool >::difference_type") -> "void":
        return _cstl.VecBool___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecBool___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< bool >::value_type":
        return _cstl.VecBool___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecBool___setitem__(self, *args)

    def pop(self) -> "std::vector< bool >::value_type":
        return _cstl.VecBool_pop(self)

    def append(self, x: "std::vector< bool >::value_type") -> "void":
        return _cstl.VecBool_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecBool_empty(self)

    def size(self) -> "std::vector< bool >::size_type":
        return _cstl.VecBool_size(self)

    def swap(self, v: "VecBool") -> "void":
        return _cstl.VecBool_swap(self, v)

    def begin(self) -> "std::vector< bool >::iterator":
        return _cstl.VecBool_begin(self)

    def end(self) -> "std::vector< bool >::iterator":
        return _cstl.VecBool_end(self)

    def rbegin(self) -> "std::vector< bool >::reverse_iterator":
        return _cstl.VecBool_rbegin(self)

    def rend(self) -> "std::vector< bool >::reverse_iterator":
        return _cstl.VecBool_rend(self)

    def clear(self) -> "void":
        return _cstl.VecBool_clear(self)

    def get_allocator(self) -> "std::vector< bool >::allocator_type":
        return _cstl.VecBool_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecBool_pop_back(self)

    def erase(self, *args) -> "std::vector< bool >::iterator":
        return _cstl.VecBool_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecBool_swiginit(self, _cstl.new_VecBool(*args))

    def push_back(self, x: "std::vector< bool >::value_type") -> "void":
        return _cstl.VecBool_push_back(self, x)

    def front(self) -> "std::vector< bool >::value_type":
        return _cstl.VecBool_front(self)

    def back(self) -> "std::vector< bool >::value_type":
        return _cstl.VecBool_back(self)

    def assign(self, n: "std::vector< bool >::size_type", x: "std::vector< bool >::value_type") -> "void":
        return _cstl.VecBool_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecBool_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecBool_insert(self, *args)

    def reserve(self, n: "std::vector< bool >::size_type") -> "void":
        return _cstl.VecBool_reserve(self, n)

    def capacity(self) -> "std::vector< bool >::size_type":
        return _cstl.VecBool_capacity(self)
    __swig_destroy__ = _cstl.delete_VecBool

# Register VecBool in _cstl:
_cstl.VecBool_swigregister(VecBool)

class VecLong(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecLong_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecLong___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecLong___bool__(self)

    def __len__(self) -> "std::vector< std::int64_t >::size_type":
        return _cstl.VecLong___len__(self)

    def __getslice__(self, i: "std::vector< std::int64_t >::difference_type", j: "std::vector< std::int64_t >::difference_type") -> "std::vector< std::int64_t,std::allocator< std::int64_t > > *":
        return _cstl.VecLong___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecLong___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::int64_t >::difference_type", j: "std::vector< std::int64_t >::difference_type") -> "void":
        return _cstl.VecLong___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecLong___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::int64_t >::value_type const &":
        return _cstl.VecLong___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecLong___setitem__(self, *args)

    def pop(self) -> "std::vector< std::int64_t >::value_type":
        return _cstl.VecLong_pop(self)

    def append(self, x: "std::vector< std::int64_t >::value_type const &") -> "void":
        return _cstl.VecLong_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecLong_empty(self)

    def size(self) -> "std::vector< std::int64_t >::size_type":
        return _cstl.VecLong_size(self)

    def swap(self, v: "VecLong") -> "void":
        return _cstl.VecLong_swap(self, v)

    def begin(self) -> "std::vector< std::int64_t >::iterator":
        return _cstl.VecLong_begin(self)

    def end(self) -> "std::vector< std::int64_t >::iterator":
        return _cstl.VecLong_end(self)

    def rbegin(self) -> "std::vector< std::int64_t >::reverse_iterator":
        return _cstl.VecLong_rbegin(self)

    def rend(self) -> "std::vector< std::int64_t >::reverse_iterator":
        return _cstl.VecLong_rend(self)

    def clear(self) -> "void":
        return _cstl.VecLong_clear(self)

    def get_allocator(self) -> "std::vector< std::int64_t >::allocator_type":
        return _cstl.VecLong_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecLong_pop_back(self)

    def erase(self, *args) -> "std::vector< std::int64_t >::iterator":
        return _cstl.VecLong_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecLong_swiginit(self, _cstl.new_VecLong(*args))

    def push_back(self, x: "std::vector< std::int64_t >::value_type const &") -> "void":
        return _cstl.VecLong_push_back(self, x)

    def front(self) -> "std::vector< std::int64_t >::value_type const &":
        return _cstl.VecLong_front(self)

    def back(self) -> "std::vector< std::int64_t >::value_type const &":
        return _cstl.VecLong_back(self)

    def assign(self, n: "std::vector< std::int64_t >::size_type", x: "std::vector< std::int64_t >::value_type const &") -> "void":
        return _cstl.VecLong_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecLong_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecLong_insert(self, *args)

    def reserve(self, n: "std::vector< std::int64_t >::size_type") -> "void":
        return _cstl.VecLong_reserve(self, n)

    def capacity(self) -> "std::vector< std::int64_t >::size_type":
        return _cstl.VecLong_capacity(self)
    __swig_destroy__ = _cstl.delete_VecLong

# Register VecLong in _cstl:
_cstl.VecLong_swigregister(VecLong)

class SetInt(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.SetInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.SetInt___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.SetInt___bool__(self)

    def __len__(self) -> "std::unordered_set< int >::size_type":
        return _cstl.SetInt___len__(self)

    def append(self, x: "std::unordered_set< int >::value_type") -> "void":
        return _cstl.SetInt_append(self, x)

    def __contains__(self, x: "std::unordered_set< int >::value_type") -> "bool":
        return _cstl.SetInt___contains__(self, x)

    def __getitem__(self, i: "std::unordered_set< int >::difference_type") -> "std::unordered_set< int >::value_type":
        return _cstl.SetInt___getitem__(self, i)

    def __init__(self, *args):
        _cstl.SetInt_swiginit(self, _cstl.new_SetInt(*args))

    def empty(self) -> "bool":
        return _cstl.SetInt_empty(self)

    def size(self) -> "std::unordered_set< int >::size_type":
        return _cstl.SetInt_size(self)

    def clear(self) -> "void":
        return _cstl.SetInt_clear(self)

    def swap(self, v: "SetInt") -> "void":
        return _cstl.SetInt_swap(self, v)

    def count(self, x: "std::unordered_set< int >::key_type const &") -> "std::unordered_set< int >::size_type":
        return _cstl.SetInt_count(self, x)

    def begin(self) -> "std::unordered_set< int >::iterator":
        return _cstl.SetInt_begin(self)

    def end(self) -> "std::unordered_set< int >::iterator":
        return _cstl.SetInt_end(self)

    def erase(self, *args) -> "void":
        return _cstl.SetInt_erase(self, *args)

    def find(self, x: "std::unordered_set< int >::key_type const &") -> "std::unordered_set< int >::iterator":
        return _cstl.SetInt_find(self, x)

    def equal_range(self, x: "std::unordered_set< int >::key_type const &") -> "std::pair< std::unordered_set< int >::iterator,std::unordered_set< int >::iterator >":
        return _cstl.SetInt_equal_range(self, x)

    def insert(self, __x: "std::unordered_set< int >::value_type const &") -> "std::pair< std::unordered_set< int >::iterator,bool >":
        return _cstl.SetInt_insert(self, __x)
    __swig_destroy__ = _cstl.delete_SetInt

# Register SetInt in _cstl:
_cstl.SetInt_swigregister(SetInt)

class SetStr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.SetStr_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.SetStr___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.SetStr___bool__(self)

    def __len__(self) -> "std::unordered_set< std::string >::size_type":
        return _cstl.SetStr___len__(self)

    def append(self, x: "std::unordered_set< std::string >::value_type") -> "void":
        return _cstl.SetStr_append(self, x)

    def __contains__(self, x: "std::unordered_set< std::string >::value_type") -> "bool":
        return _cstl.SetStr___contains__(self, x)

    def __getitem__(self, i: "std::unordered_set< std::string >::difference_type") -> "std::unordered_set< std::string >::value_type":
        return _cstl.SetStr___getitem__(self, i)

    def __init__(self, *args):
        _cstl.SetStr_swiginit(self, _cstl.new_SetStr(*args))

    def empty(self) -> "bool":
        return _cstl.SetStr_empty(self)

    def size(self) -> "std::unordered_set< std::string >::size_type":
        return _cstl.SetStr_size(self)

    def clear(self) -> "void":
        return _cstl.SetStr_clear(self)

    def swap(self, v: "SetStr") -> "void":
        return _cstl.SetStr_swap(self, v)

    def count(self, x: "std::unordered_set< std::string >::key_type const &") -> "std::unordered_set< std::string >::size_type":
        return _cstl.SetStr_count(self, x)

    def begin(self) -> "std::unordered_set< std::string >::iterator":
        return _cstl.SetStr_begin(self)

    def end(self) -> "std::unordered_set< std::string >::iterator":
        return _cstl.SetStr_end(self)

    def erase(self, *args) -> "void":
        return _cstl.SetStr_erase(self, *args)

    def find(self, x: "std::unordered_set< std::string >::key_type const &") -> "std::unordered_set< std::string >::iterator":
        return _cstl.SetStr_find(self, x)

    def equal_range(self, x: "std::unordered_set< std::string >::key_type const &") -> "std::pair< std::unordered_set< std::string >::iterator,std::unordered_set< std::string >::iterator >":
        return _cstl.SetStr_equal_range(self, x)

    def insert(self, __x: "std::unordered_set< std::string >::value_type const &") -> "std::pair< std::unordered_set< std::string >::iterator,bool >":
        return _cstl.SetStr_insert(self, __x)
    __swig_destroy__ = _cstl.delete_SetStr

# Register SetStr in _cstl:
_cstl.SetStr_swigregister(SetStr)

class SetLong(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.SetLong_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.SetLong___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.SetLong___bool__(self)

    def __len__(self) -> "std::unordered_set< std::int64_t >::size_type":
        return _cstl.SetLong___len__(self)

    def append(self, x: "std::unordered_set< std::int64_t >::value_type") -> "void":
        return _cstl.SetLong_append(self, x)

    def __contains__(self, x: "std::unordered_set< std::int64_t >::value_type") -> "bool":
        return _cstl.SetLong___contains__(self, x)

    def __getitem__(self, i: "std::unordered_set< std::int64_t >::difference_type") -> "std::unordered_set< std::int64_t >::value_type":
        return _cstl.SetLong___getitem__(self, i)

    def __init__(self, *args):
        _cstl.SetLong_swiginit(self, _cstl.new_SetLong(*args))

    def empty(self) -> "bool":
        return _cstl.SetLong_empty(self)

    def size(self) -> "std::unordered_set< std::int64_t >::size_type":
        return _cstl.SetLong_size(self)

    def clear(self) -> "void":
        return _cstl.SetLong_clear(self)

    def swap(self, v: "SetLong") -> "void":
        return _cstl.SetLong_swap(self, v)

    def count(self, x: "std::unordered_set< std::int64_t >::key_type const &") -> "std::unordered_set< std::int64_t >::size_type":
        return _cstl.SetLong_count(self, x)

    def begin(self) -> "std::unordered_set< std::int64_t >::iterator":
        return _cstl.SetLong_begin(self)

    def end(self) -> "std::unordered_set< std::int64_t >::iterator":
        return _cstl.SetLong_end(self)

    def erase(self, *args) -> "void":
        return _cstl.SetLong_erase(self, *args)

    def find(self, x: "std::unordered_set< std::int64_t >::key_type const &") -> "std::unordered_set< std::int64_t >::iterator":
        return _cstl.SetLong_find(self, x)

    def equal_range(self, x: "std::unordered_set< std::int64_t >::key_type const &") -> "std::pair< std::unordered_set< std::int64_t >::iterator,std::unordered_set< std::int64_t >::iterator >":
        return _cstl.SetLong_equal_range(self, x)

    def insert(self, __x: "std::unordered_set< std::int64_t >::value_type const &") -> "std::pair< std::unordered_set< std::int64_t >::iterator,bool >":
        return _cstl.SetLong_insert(self, __x)
    __swig_destroy__ = _cstl.delete_SetLong

# Register SetLong in _cstl:
_cstl.SetLong_swigregister(SetLong)

class MapIntInt(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntInt___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntInt___bool__(self)

    def __len__(self) -> "std::unordered_map< int,int >::size_type":
        return _cstl.MapIntInt___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,int >::key_type const &") -> "std::unordered_map< int,int >::mapped_type const &":
        return _cstl.MapIntInt___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,int >::key_type const &") -> "void":
        return _cstl.MapIntInt___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,int >::key_type const &") -> "bool":
        return _cstl.MapIntInt_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntInt_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntInt_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntInt_items(self)

    def __contains__(self, key: "std::unordered_map< int,int >::key_type const &") -> "bool":
        return _cstl.MapIntInt___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntInt_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntInt_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntInt___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntInt_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntInt_swiginit(self, _cstl.new_MapIntInt(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntInt_empty(self)

    def size(self) -> "std::unordered_map< int,int >::size_type":
        return _cstl.MapIntInt_size(self)

    def swap(self, v: "MapIntInt") -> "void":
        return _cstl.MapIntInt_swap(self, v)

    def begin(self) -> "std::unordered_map< int,int >::iterator":
        return _cstl.MapIntInt_begin(self)

    def end(self) -> "std::unordered_map< int,int >::iterator":
        return _cstl.MapIntInt_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntInt_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,int >::allocator_type":
        return _cstl.MapIntInt_get_allocator(self)

    def count(self, x: "std::unordered_map< int,int >::key_type const &") -> "std::unordered_map< int,int >::size_type":
        return _cstl.MapIntInt_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntInt_erase(self, *args)

    def find(self, x: "std::unordered_map< int,int >::key_type const &") -> "std::unordered_map< int,int >::iterator":
        return _cstl.MapIntInt_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntInt

# Register MapIntInt in _cstl:
_cstl.MapIntInt_swigregister(MapIntInt)

class MapIntStr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntStr_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntStr___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntStr___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::string >::size_type":
        return _cstl.MapIntStr___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::string >::key_type const &") -> "std::unordered_map< int,std::string >::mapped_type const &":
        return _cstl.MapIntStr___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::string >::key_type const &") -> "void":
        return _cstl.MapIntStr___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::string >::key_type const &") -> "bool":
        return _cstl.MapIntStr_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntStr_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntStr_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntStr_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::string >::key_type const &") -> "bool":
        return _cstl.MapIntStr___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntStr_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntStr_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntStr___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntStr_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntStr_swiginit(self, _cstl.new_MapIntStr(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntStr_empty(self)

    def size(self) -> "std::unordered_map< int,std::string >::size_type":
        return _cstl.MapIntStr_size(self)

    def swap(self, v: "MapIntStr") -> "void":
        return _cstl.MapIntStr_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::string >::iterator":
        return _cstl.MapIntStr_begin(self)

    def end(self) -> "std::unordered_map< int,std::string >::iterator":
        return _cstl.MapIntStr_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntStr_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::string >::allocator_type":
        return _cstl.MapIntStr_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::string >::key_type const &") -> "std::unordered_map< int,std::string >::size_type":
        return _cstl.MapIntStr_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntStr_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::string >::key_type const &") -> "std::unordered_map< int,std::string >::iterator":
        return _cstl.MapIntStr_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntStr

# Register MapIntStr in _cstl:
_cstl.MapIntStr_swigregister(MapIntStr)

class MapIntFloat(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntFloat_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntFloat___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntFloat___bool__(self)

    def __len__(self) -> "std::unordered_map< int,float >::size_type":
        return _cstl.MapIntFloat___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,float >::key_type const &") -> "std::unordered_map< int,float >::mapped_type const &":
        return _cstl.MapIntFloat___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,float >::key_type const &") -> "void":
        return _cstl.MapIntFloat___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,float >::key_type const &") -> "bool":
        return _cstl.MapIntFloat_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntFloat_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntFloat_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntFloat_items(self)

    def __contains__(self, key: "std::unordered_map< int,float >::key_type const &") -> "bool":
        return _cstl.MapIntFloat___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntFloat_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntFloat_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntFloat___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntFloat_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntFloat_swiginit(self, _cstl.new_MapIntFloat(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntFloat_empty(self)

    def size(self) -> "std::unordered_map< int,float >::size_type":
        return _cstl.MapIntFloat_size(self)

    def swap(self, v: "MapIntFloat") -> "void":
        return _cstl.MapIntFloat_swap(self, v)

    def begin(self) -> "std::unordered_map< int,float >::iterator":
        return _cstl.MapIntFloat_begin(self)

    def end(self) -> "std::unordered_map< int,float >::iterator":
        return _cstl.MapIntFloat_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntFloat_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,float >::allocator_type":
        return _cstl.MapIntFloat_get_allocator(self)

    def count(self, x: "std::unordered_map< int,float >::key_type const &") -> "std::unordered_map< int,float >::size_type":
        return _cstl.MapIntFloat_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntFloat_erase(self, *args)

    def find(self, x: "std::unordered_map< int,float >::key_type const &") -> "std::unordered_map< int,float >::iterator":
        return _cstl.MapIntFloat_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntFloat

# Register MapIntFloat in _cstl:
_cstl.MapIntFloat_swigregister(MapIntFloat)

class MapIntDouble(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntDouble_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntDouble___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntDouble___bool__(self)

    def __len__(self) -> "std::unordered_map< int,double >::size_type":
        return _cstl.MapIntDouble___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,double >::key_type const &") -> "std::unordered_map< int,double >::mapped_type const &":
        return _cstl.MapIntDouble___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,double >::key_type const &") -> "void":
        return _cstl.MapIntDouble___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,double >::key_type const &") -> "bool":
        return _cstl.MapIntDouble_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntDouble_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntDouble_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntDouble_items(self)

    def __contains__(self, key: "std::unordered_map< int,double >::key_type const &") -> "bool":
        return _cstl.MapIntDouble___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntDouble_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntDouble_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntDouble___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntDouble_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntDouble_swiginit(self, _cstl.new_MapIntDouble(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntDouble_empty(self)

    def size(self) -> "std::unordered_map< int,double >::size_type":
        return _cstl.MapIntDouble_size(self)

    def swap(self, v: "MapIntDouble") -> "void":
        return _cstl.MapIntDouble_swap(self, v)

    def begin(self) -> "std::unordered_map< int,double >::iterator":
        return _cstl.MapIntDouble_begin(self)

    def end(self) -> "std::unordered_map< int,double >::iterator":
        return _cstl.MapIntDouble_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntDouble_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,double >::allocator_type":
        return _cstl.MapIntDouble_get_allocator(self)

    def count(self, x: "std::unordered_map< int,double >::key_type const &") -> "std::unordered_map< int,double >::size_type":
        return _cstl.MapIntDouble_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntDouble_erase(self, *args)

    def find(self, x: "std::unordered_map< int,double >::key_type const &") -> "std::unordered_map< int,double >::iterator":
        return _cstl.MapIntDouble_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntDouble

# Register MapIntDouble in _cstl:
_cstl.MapIntDouble_swigregister(MapIntDouble)

class MapIntBool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntBool_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntBool___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntBool___bool__(self)

    def __len__(self) -> "std::unordered_map< int,bool >::size_type":
        return _cstl.MapIntBool___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,bool >::key_type const &") -> "std::unordered_map< int,bool >::mapped_type const &":
        return _cstl.MapIntBool___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,bool >::key_type const &") -> "void":
        return _cstl.MapIntBool___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,bool >::key_type const &") -> "bool":
        return _cstl.MapIntBool_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntBool_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntBool_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntBool_items(self)

    def __contains__(self, key: "std::unordered_map< int,bool >::key_type const &") -> "bool":
        return _cstl.MapIntBool___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntBool_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntBool_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntBool___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntBool_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntBool_swiginit(self, _cstl.new_MapIntBool(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntBool_empty(self)

    def size(self) -> "std::unordered_map< int,bool >::size_type":
        return _cstl.MapIntBool_size(self)

    def swap(self, v: "MapIntBool") -> "void":
        return _cstl.MapIntBool_swap(self, v)

    def begin(self) -> "std::unordered_map< int,bool >::iterator":
        return _cstl.MapIntBool_begin(self)

    def end(self) -> "std::unordered_map< int,bool >::iterator":
        return _cstl.MapIntBool_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntBool_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,bool >::allocator_type":
        return _cstl.MapIntBool_get_allocator(self)

    def count(self, x: "std::unordered_map< int,bool >::key_type const &") -> "std::unordered_map< int,bool >::size_type":
        return _cstl.MapIntBool_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntBool_erase(self, *args)

    def find(self, x: "std::unordered_map< int,bool >::key_type const &") -> "std::unordered_map< int,bool >::iterator":
        return _cstl.MapIntBool_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntBool

# Register MapIntBool in _cstl:
_cstl.MapIntBool_swigregister(MapIntBool)

class MapIntLong(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntLong_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntLong___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntLong___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::int64_t >::size_type":
        return _cstl.MapIntLong___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::int64_t >::key_type const &") -> "std::unordered_map< int,std::int64_t >::mapped_type const &":
        return _cstl.MapIntLong___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::int64_t >::key_type const &") -> "void":
        return _cstl.MapIntLong___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::int64_t >::key_type const &") -> "bool":
        return _cstl.MapIntLong_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntLong_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntLong_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntLong_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::int64_t >::key_type const &") -> "bool":
        return _cstl.MapIntLong___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntLong_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntLong_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntLong___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntLong_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntLong_swiginit(self, _cstl.new_MapIntLong(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntLong_empty(self)

    def size(self) -> "std::unordered_map< int,std::int64_t >::size_type":
        return _cstl.MapIntLong_size(self)

    def swap(self, v: "MapIntLong") -> "void":
        return _cstl.MapIntLong_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::int64_t >::iterator":
        return _cstl.MapIntLong_begin(self)

    def end(self) -> "std::unordered_map< int,std::int64_t >::iterator":
        return _cstl.MapIntLong_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntLong_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::int64_t >::allocator_type":
        return _cstl.MapIntLong_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::int64_t >::key_type const &") -> "std::unordered_map< int,std::int64_t >::size_type":
        return _cstl.MapIntLong_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntLong_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::int64_t >::key_type const &") -> "std::unordered_map< int,std::int64_t >::iterator":
        return _cstl.MapIntLong_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntLong

# Register MapIntLong in _cstl:
_cstl.MapIntLong_swigregister(MapIntLong)

class MapStrInt(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrInt___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrInt___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,int >::size_type":
        return _cstl.MapStrInt___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,int >::key_type const &") -> "std::unordered_map< std::string,int >::mapped_type const &":
        return _cstl.MapStrInt___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,int >::key_type const &") -> "void":
        return _cstl.MapStrInt___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,int >::key_type const &") -> "bool":
        return _cstl.MapStrInt_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrInt_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrInt_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrInt_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,int >::key_type const &") -> "bool":
        return _cstl.MapStrInt___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrInt_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrInt_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrInt___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrInt_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrInt_swiginit(self, _cstl.new_MapStrInt(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrInt_empty(self)

    def size(self) -> "std::unordered_map< std::string,int >::size_type":
        return _cstl.MapStrInt_size(self)

    def swap(self, v: "MapStrInt") -> "void":
        return _cstl.MapStrInt_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,int >::iterator":
        return _cstl.MapStrInt_begin(self)

    def end(self) -> "std::unordered_map< std::string,int >::iterator":
        return _cstl.MapStrInt_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrInt_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,int >::allocator_type":
        return _cstl.MapStrInt_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,int >::key_type const &") -> "std::unordered_map< std::string,int >::size_type":
        return _cstl.MapStrInt_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrInt_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,int >::key_type const &") -> "std::unordered_map< std::string,int >::iterator":
        return _cstl.MapStrInt_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrInt

# Register MapStrInt in _cstl:
_cstl.MapStrInt_swigregister(MapStrInt)

class MapStrStr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrStr_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrStr___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrStr___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::string >::size_type":
        return _cstl.MapStrStr___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::string >::key_type const &") -> "std::unordered_map< std::string,std::string >::mapped_type const &":
        return _cstl.MapStrStr___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::string >::key_type const &") -> "void":
        return _cstl.MapStrStr___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::string >::key_type const &") -> "bool":
        return _cstl.MapStrStr_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrStr_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrStr_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrStr_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::string >::key_type const &") -> "bool":
        return _cstl.MapStrStr___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrStr_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrStr_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrStr___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrStr_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrStr_swiginit(self, _cstl.new_MapStrStr(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrStr_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::string >::size_type":
        return _cstl.MapStrStr_size(self)

    def swap(self, v: "MapStrStr") -> "void":
        return _cstl.MapStrStr_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::string >::iterator":
        return _cstl.MapStrStr_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::string >::iterator":
        return _cstl.MapStrStr_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrStr_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::string >::allocator_type":
        return _cstl.MapStrStr_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::string >::key_type const &") -> "std::unordered_map< std::string,std::string >::size_type":
        return _cstl.MapStrStr_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrStr_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::string >::key_type const &") -> "std::unordered_map< std::string,std::string >::iterator":
        return _cstl.MapStrStr_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrStr

# Register MapStrStr in _cstl:
_cstl.MapStrStr_swigregister(MapStrStr)

class MapStrFloat(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrFloat_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrFloat___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrFloat___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,float >::size_type":
        return _cstl.MapStrFloat___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,float >::key_type const &") -> "std::unordered_map< std::string,float >::mapped_type const &":
        return _cstl.MapStrFloat___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,float >::key_type const &") -> "void":
        return _cstl.MapStrFloat___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,float >::key_type const &") -> "bool":
        return _cstl.MapStrFloat_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrFloat_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrFloat_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrFloat_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,float >::key_type const &") -> "bool":
        return _cstl.MapStrFloat___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrFloat_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrFloat_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrFloat___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrFloat_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrFloat_swiginit(self, _cstl.new_MapStrFloat(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrFloat_empty(self)

    def size(self) -> "std::unordered_map< std::string,float >::size_type":
        return _cstl.MapStrFloat_size(self)

    def swap(self, v: "MapStrFloat") -> "void":
        return _cstl.MapStrFloat_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,float >::iterator":
        return _cstl.MapStrFloat_begin(self)

    def end(self) -> "std::unordered_map< std::string,float >::iterator":
        return _cstl.MapStrFloat_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrFloat_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,float >::allocator_type":
        return _cstl.MapStrFloat_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,float >::key_type const &") -> "std::unordered_map< std::string,float >::size_type":
        return _cstl.MapStrFloat_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrFloat_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,float >::key_type const &") -> "std::unordered_map< std::string,float >::iterator":
        return _cstl.MapStrFloat_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrFloat

# Register MapStrFloat in _cstl:
_cstl.MapStrFloat_swigregister(MapStrFloat)

class MapStrDouble(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrDouble_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrDouble___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrDouble___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,double >::size_type":
        return _cstl.MapStrDouble___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,double >::key_type const &") -> "std::unordered_map< std::string,double >::mapped_type const &":
        return _cstl.MapStrDouble___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,double >::key_type const &") -> "void":
        return _cstl.MapStrDouble___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,double >::key_type const &") -> "bool":
        return _cstl.MapStrDouble_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrDouble_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrDouble_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrDouble_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,double >::key_type const &") -> "bool":
        return _cstl.MapStrDouble___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrDouble_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrDouble_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrDouble___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrDouble_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrDouble_swiginit(self, _cstl.new_MapStrDouble(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrDouble_empty(self)

    def size(self) -> "std::unordered_map< std::string,double >::size_type":
        return _cstl.MapStrDouble_size(self)

    def swap(self, v: "MapStrDouble") -> "void":
        return _cstl.MapStrDouble_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,double >::iterator":
        return _cstl.MapStrDouble_begin(self)

    def end(self) -> "std::unordered_map< std::string,double >::iterator":
        return _cstl.MapStrDouble_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrDouble_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,double >::allocator_type":
        return _cstl.MapStrDouble_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,double >::key_type const &") -> "std::unordered_map< std::string,double >::size_type":
        return _cstl.MapStrDouble_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrDouble_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,double >::key_type const &") -> "std::unordered_map< std::string,double >::iterator":
        return _cstl.MapStrDouble_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrDouble

# Register MapStrDouble in _cstl:
_cstl.MapStrDouble_swigregister(MapStrDouble)

class MapStrBool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrBool_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrBool___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrBool___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,bool >::size_type":
        return _cstl.MapStrBool___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,bool >::key_type const &") -> "std::unordered_map< std::string,bool >::mapped_type const &":
        return _cstl.MapStrBool___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,bool >::key_type const &") -> "void":
        return _cstl.MapStrBool___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,bool >::key_type const &") -> "bool":
        return _cstl.MapStrBool_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrBool_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrBool_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrBool_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,bool >::key_type const &") -> "bool":
        return _cstl.MapStrBool___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrBool_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrBool_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrBool___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrBool_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrBool_swiginit(self, _cstl.new_MapStrBool(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrBool_empty(self)

    def size(self) -> "std::unordered_map< std::string,bool >::size_type":
        return _cstl.MapStrBool_size(self)

    def swap(self, v: "MapStrBool") -> "void":
        return _cstl.MapStrBool_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,bool >::iterator":
        return _cstl.MapStrBool_begin(self)

    def end(self) -> "std::unordered_map< std::string,bool >::iterator":
        return _cstl.MapStrBool_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrBool_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,bool >::allocator_type":
        return _cstl.MapStrBool_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,bool >::key_type const &") -> "std::unordered_map< std::string,bool >::size_type":
        return _cstl.MapStrBool_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrBool_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,bool >::key_type const &") -> "std::unordered_map< std::string,bool >::iterator":
        return _cstl.MapStrBool_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrBool

# Register MapStrBool in _cstl:
_cstl.MapStrBool_swigregister(MapStrBool)

class MapStrLong(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrLong_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrLong___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrLong___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::int64_t >::size_type":
        return _cstl.MapStrLong___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::int64_t >::key_type const &") -> "std::unordered_map< std::string,std::int64_t >::mapped_type const &":
        return _cstl.MapStrLong___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::int64_t >::key_type const &") -> "void":
        return _cstl.MapStrLong___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::int64_t >::key_type const &") -> "bool":
        return _cstl.MapStrLong_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrLong_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrLong_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrLong_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::int64_t >::key_type const &") -> "bool":
        return _cstl.MapStrLong___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrLong_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrLong_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrLong___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrLong_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrLong_swiginit(self, _cstl.new_MapStrLong(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrLong_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::int64_t >::size_type":
        return _cstl.MapStrLong_size(self)

    def swap(self, v: "MapStrLong") -> "void":
        return _cstl.MapStrLong_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::int64_t >::iterator":
        return _cstl.MapStrLong_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::int64_t >::iterator":
        return _cstl.MapStrLong_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrLong_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::int64_t >::allocator_type":
        return _cstl.MapStrLong_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::int64_t >::key_type const &") -> "std::unordered_map< std::string,std::int64_t >::size_type":
        return _cstl.MapStrLong_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrLong_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::int64_t >::key_type const &") -> "std::unordered_map< std::string,std::int64_t >::iterator":
        return _cstl.MapStrLong_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrLong

# Register MapStrLong in _cstl:
_cstl.MapStrLong_swigregister(MapStrLong)

class MapLongInt(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongInt___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongInt___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,int >::size_type":
        return _cstl.MapLongInt___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,int >::key_type const &") -> "std::unordered_map< std::int64_t,int >::mapped_type const &":
        return _cstl.MapLongInt___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,int >::key_type const &") -> "void":
        return _cstl.MapLongInt___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,int >::key_type const &") -> "bool":
        return _cstl.MapLongInt_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongInt_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongInt_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongInt_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,int >::key_type const &") -> "bool":
        return _cstl.MapLongInt___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongInt_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongInt_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongInt___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongInt_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongInt_swiginit(self, _cstl.new_MapLongInt(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongInt_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,int >::size_type":
        return _cstl.MapLongInt_size(self)

    def swap(self, v: "MapLongInt") -> "void":
        return _cstl.MapLongInt_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,int >::iterator":
        return _cstl.MapLongInt_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,int >::iterator":
        return _cstl.MapLongInt_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongInt_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,int >::allocator_type":
        return _cstl.MapLongInt_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,int >::key_type const &") -> "std::unordered_map< std::int64_t,int >::size_type":
        return _cstl.MapLongInt_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongInt_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,int >::key_type const &") -> "std::unordered_map< std::int64_t,int >::iterator":
        return _cstl.MapLongInt_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongInt

# Register MapLongInt in _cstl:
_cstl.MapLongInt_swigregister(MapLongInt)

class MapLongStr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongStr_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongStr___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongStr___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::string >::size_type":
        return _cstl.MapLongStr___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::string >::key_type const &") -> "std::unordered_map< std::int64_t,std::string >::mapped_type const &":
        return _cstl.MapLongStr___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::string >::key_type const &") -> "void":
        return _cstl.MapLongStr___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::string >::key_type const &") -> "bool":
        return _cstl.MapLongStr_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongStr_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongStr_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongStr_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::string >::key_type const &") -> "bool":
        return _cstl.MapLongStr___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongStr_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongStr_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongStr___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongStr_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongStr_swiginit(self, _cstl.new_MapLongStr(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongStr_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::string >::size_type":
        return _cstl.MapLongStr_size(self)

    def swap(self, v: "MapLongStr") -> "void":
        return _cstl.MapLongStr_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::string >::iterator":
        return _cstl.MapLongStr_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::string >::iterator":
        return _cstl.MapLongStr_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongStr_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::string >::allocator_type":
        return _cstl.MapLongStr_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::string >::key_type const &") -> "std::unordered_map< std::int64_t,std::string >::size_type":
        return _cstl.MapLongStr_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongStr_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::string >::key_type const &") -> "std::unordered_map< std::int64_t,std::string >::iterator":
        return _cstl.MapLongStr_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongStr

# Register MapLongStr in _cstl:
_cstl.MapLongStr_swigregister(MapLongStr)

class MapLongFloat(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongFloat_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongFloat___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongFloat___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,float >::size_type":
        return _cstl.MapLongFloat___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,float >::key_type const &") -> "std::unordered_map< std::int64_t,float >::mapped_type const &":
        return _cstl.MapLongFloat___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,float >::key_type const &") -> "void":
        return _cstl.MapLongFloat___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,float >::key_type const &") -> "bool":
        return _cstl.MapLongFloat_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongFloat_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongFloat_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongFloat_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,float >::key_type const &") -> "bool":
        return _cstl.MapLongFloat___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongFloat_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongFloat_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongFloat___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongFloat_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongFloat_swiginit(self, _cstl.new_MapLongFloat(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongFloat_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,float >::size_type":
        return _cstl.MapLongFloat_size(self)

    def swap(self, v: "MapLongFloat") -> "void":
        return _cstl.MapLongFloat_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,float >::iterator":
        return _cstl.MapLongFloat_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,float >::iterator":
        return _cstl.MapLongFloat_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongFloat_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,float >::allocator_type":
        return _cstl.MapLongFloat_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,float >::key_type const &") -> "std::unordered_map< std::int64_t,float >::size_type":
        return _cstl.MapLongFloat_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongFloat_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,float >::key_type const &") -> "std::unordered_map< std::int64_t,float >::iterator":
        return _cstl.MapLongFloat_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongFloat

# Register MapLongFloat in _cstl:
_cstl.MapLongFloat_swigregister(MapLongFloat)

class MapLongDouble(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongDouble_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongDouble___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongDouble___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,double >::size_type":
        return _cstl.MapLongDouble___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,double >::key_type const &") -> "std::unordered_map< std::int64_t,double >::mapped_type const &":
        return _cstl.MapLongDouble___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,double >::key_type const &") -> "void":
        return _cstl.MapLongDouble___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,double >::key_type const &") -> "bool":
        return _cstl.MapLongDouble_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongDouble_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongDouble_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongDouble_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,double >::key_type const &") -> "bool":
        return _cstl.MapLongDouble___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongDouble_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongDouble_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongDouble___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongDouble_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongDouble_swiginit(self, _cstl.new_MapLongDouble(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongDouble_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,double >::size_type":
        return _cstl.MapLongDouble_size(self)

    def swap(self, v: "MapLongDouble") -> "void":
        return _cstl.MapLongDouble_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,double >::iterator":
        return _cstl.MapLongDouble_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,double >::iterator":
        return _cstl.MapLongDouble_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongDouble_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,double >::allocator_type":
        return _cstl.MapLongDouble_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,double >::key_type const &") -> "std::unordered_map< std::int64_t,double >::size_type":
        return _cstl.MapLongDouble_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongDouble_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,double >::key_type const &") -> "std::unordered_map< std::int64_t,double >::iterator":
        return _cstl.MapLongDouble_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongDouble

# Register MapLongDouble in _cstl:
_cstl.MapLongDouble_swigregister(MapLongDouble)

class MapLongBool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongBool_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongBool___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongBool___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,bool >::size_type":
        return _cstl.MapLongBool___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,bool >::key_type const &") -> "std::unordered_map< std::int64_t,bool >::mapped_type const &":
        return _cstl.MapLongBool___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,bool >::key_type const &") -> "void":
        return _cstl.MapLongBool___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,bool >::key_type const &") -> "bool":
        return _cstl.MapLongBool_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongBool_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongBool_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongBool_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,bool >::key_type const &") -> "bool":
        return _cstl.MapLongBool___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongBool_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongBool_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongBool___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongBool_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongBool_swiginit(self, _cstl.new_MapLongBool(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongBool_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,bool >::size_type":
        return _cstl.MapLongBool_size(self)

    def swap(self, v: "MapLongBool") -> "void":
        return _cstl.MapLongBool_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,bool >::iterator":
        return _cstl.MapLongBool_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,bool >::iterator":
        return _cstl.MapLongBool_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongBool_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,bool >::allocator_type":
        return _cstl.MapLongBool_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,bool >::key_type const &") -> "std::unordered_map< std::int64_t,bool >::size_type":
        return _cstl.MapLongBool_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongBool_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,bool >::key_type const &") -> "std::unordered_map< std::int64_t,bool >::iterator":
        return _cstl.MapLongBool_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongBool

# Register MapLongBool in _cstl:
_cstl.MapLongBool_swigregister(MapLongBool)

class MapLongLong(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongLong_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongLong___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongLong___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::int64_t >::size_type":
        return _cstl.MapLongLong___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::int64_t >::key_type const &") -> "std::unordered_map< std::int64_t,std::int64_t >::mapped_type const &":
        return _cstl.MapLongLong___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::int64_t >::key_type const &") -> "void":
        return _cstl.MapLongLong___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::int64_t >::key_type const &") -> "bool":
        return _cstl.MapLongLong_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongLong_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongLong_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongLong_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::int64_t >::key_type const &") -> "bool":
        return _cstl.MapLongLong___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongLong_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongLong_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongLong___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongLong_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongLong_swiginit(self, _cstl.new_MapLongLong(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongLong_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::int64_t >::size_type":
        return _cstl.MapLongLong_size(self)

    def swap(self, v: "MapLongLong") -> "void":
        return _cstl.MapLongLong_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::int64_t >::iterator":
        return _cstl.MapLongLong_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::int64_t >::iterator":
        return _cstl.MapLongLong_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongLong_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::int64_t >::allocator_type":
        return _cstl.MapLongLong_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::int64_t >::key_type const &") -> "std::unordered_map< std::int64_t,std::int64_t >::size_type":
        return _cstl.MapLongLong_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongLong_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::int64_t >::key_type const &") -> "std::unordered_map< std::int64_t,std::int64_t >::iterator":
        return _cstl.MapLongLong_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongLong

# Register MapLongLong in _cstl:
_cstl.MapLongLong_swigregister(MapLongLong)

class VecVecInt(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecVecInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecVecInt___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecVecInt___bool__(self)

    def __len__(self) -> "std::vector< std::vector< int > >::size_type":
        return _cstl.VecVecInt___len__(self)

    def __getslice__(self, i: "std::vector< std::vector< int > >::difference_type", j: "std::vector< std::vector< int > >::difference_type") -> "std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *":
        return _cstl.VecVecInt___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecVecInt___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::vector< int > >::difference_type", j: "std::vector< std::vector< int > >::difference_type") -> "void":
        return _cstl.VecVecInt___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecVecInt___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::vector< int > >::value_type const &":
        return _cstl.VecVecInt___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecVecInt___setitem__(self, *args)

    def pop(self) -> "std::vector< std::vector< int > >::value_type":
        return _cstl.VecVecInt_pop(self)

    def append(self, x: "VecInt") -> "void":
        return _cstl.VecVecInt_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecVecInt_empty(self)

    def size(self) -> "std::vector< std::vector< int > >::size_type":
        return _cstl.VecVecInt_size(self)

    def swap(self, v: "VecVecInt") -> "void":
        return _cstl.VecVecInt_swap(self, v)

    def begin(self) -> "std::vector< std::vector< int > >::iterator":
        return _cstl.VecVecInt_begin(self)

    def end(self) -> "std::vector< std::vector< int > >::iterator":
        return _cstl.VecVecInt_end(self)

    def rbegin(self) -> "std::vector< std::vector< int > >::reverse_iterator":
        return _cstl.VecVecInt_rbegin(self)

    def rend(self) -> "std::vector< std::vector< int > >::reverse_iterator":
        return _cstl.VecVecInt_rend(self)

    def clear(self) -> "void":
        return _cstl.VecVecInt_clear(self)

    def get_allocator(self) -> "std::vector< std::vector< int > >::allocator_type":
        return _cstl.VecVecInt_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecVecInt_pop_back(self)

    def erase(self, *args) -> "std::vector< std::vector< int > >::iterator":
        return _cstl.VecVecInt_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecVecInt_swiginit(self, _cstl.new_VecVecInt(*args))

    def push_back(self, x: "VecInt") -> "void":
        return _cstl.VecVecInt_push_back(self, x)

    def front(self) -> "std::vector< std::vector< int > >::value_type const &":
        return _cstl.VecVecInt_front(self)

    def back(self) -> "std::vector< std::vector< int > >::value_type const &":
        return _cstl.VecVecInt_back(self)

    def assign(self, n: "std::vector< std::vector< int > >::size_type", x: "VecInt") -> "void":
        return _cstl.VecVecInt_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecVecInt_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecVecInt_insert(self, *args)

    def reserve(self, n: "std::vector< std::vector< int > >::size_type") -> "void":
        return _cstl.VecVecInt_reserve(self, n)

    def capacity(self) -> "std::vector< std::vector< int > >::size_type":
        return _cstl.VecVecInt_capacity(self)
    __swig_destroy__ = _cstl.delete_VecVecInt

# Register VecVecInt in _cstl:
_cstl.VecVecInt_swigregister(VecVecInt)

class VecVecStr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecVecStr_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecVecStr___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecVecStr___bool__(self)

    def __len__(self) -> "std::vector< std::vector< std::string > >::size_type":
        return _cstl.VecVecStr___len__(self)

    def __getslice__(self, i: "std::vector< std::vector< std::string > >::difference_type", j: "std::vector< std::vector< std::string > >::difference_type") -> "std::vector< std::vector< std::string,std::allocator< std::string > >,std::allocator< std::vector< std::string,std::allocator< std::string > > > > *":
        return _cstl.VecVecStr___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecVecStr___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::vector< std::string > >::difference_type", j: "std::vector< std::vector< std::string > >::difference_type") -> "void":
        return _cstl.VecVecStr___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecVecStr___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::vector< std::string > >::value_type const &":
        return _cstl.VecVecStr___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecVecStr___setitem__(self, *args)

    def pop(self) -> "std::vector< std::vector< std::string > >::value_type":
        return _cstl.VecVecStr_pop(self)

    def append(self, x: "VecStr") -> "void":
        return _cstl.VecVecStr_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecVecStr_empty(self)

    def size(self) -> "std::vector< std::vector< std::string > >::size_type":
        return _cstl.VecVecStr_size(self)

    def swap(self, v: "VecVecStr") -> "void":
        return _cstl.VecVecStr_swap(self, v)

    def begin(self) -> "std::vector< std::vector< std::string > >::iterator":
        return _cstl.VecVecStr_begin(self)

    def end(self) -> "std::vector< std::vector< std::string > >::iterator":
        return _cstl.VecVecStr_end(self)

    def rbegin(self) -> "std::vector< std::vector< std::string > >::reverse_iterator":
        return _cstl.VecVecStr_rbegin(self)

    def rend(self) -> "std::vector< std::vector< std::string > >::reverse_iterator":
        return _cstl.VecVecStr_rend(self)

    def clear(self) -> "void":
        return _cstl.VecVecStr_clear(self)

    def get_allocator(self) -> "std::vector< std::vector< std::string > >::allocator_type":
        return _cstl.VecVecStr_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecVecStr_pop_back(self)

    def erase(self, *args) -> "std::vector< std::vector< std::string > >::iterator":
        return _cstl.VecVecStr_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecVecStr_swiginit(self, _cstl.new_VecVecStr(*args))

    def push_back(self, x: "VecStr") -> "void":
        return _cstl.VecVecStr_push_back(self, x)

    def front(self) -> "std::vector< std::vector< std::string > >::value_type const &":
        return _cstl.VecVecStr_front(self)

    def back(self) -> "std::vector< std::vector< std::string > >::value_type const &":
        return _cstl.VecVecStr_back(self)

    def assign(self, n: "std::vector< std::vector< std::string > >::size_type", x: "VecStr") -> "void":
        return _cstl.VecVecStr_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecVecStr_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecVecStr_insert(self, *args)

    def reserve(self, n: "std::vector< std::vector< std::string > >::size_type") -> "void":
        return _cstl.VecVecStr_reserve(self, n)

    def capacity(self) -> "std::vector< std::vector< std::string > >::size_type":
        return _cstl.VecVecStr_capacity(self)
    __swig_destroy__ = _cstl.delete_VecVecStr

# Register VecVecStr in _cstl:
_cstl.VecVecStr_swigregister(VecVecStr)

class VecVecFloat(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecVecFloat_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecVecFloat___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecVecFloat___bool__(self)

    def __len__(self) -> "std::vector< std::vector< float > >::size_type":
        return _cstl.VecVecFloat___len__(self)

    def __getslice__(self, i: "std::vector< std::vector< float > >::difference_type", j: "std::vector< std::vector< float > >::difference_type") -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > *":
        return _cstl.VecVecFloat___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecVecFloat___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::vector< float > >::difference_type", j: "std::vector< std::vector< float > >::difference_type") -> "void":
        return _cstl.VecVecFloat___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecVecFloat___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::vector< float > >::value_type const &":
        return _cstl.VecVecFloat___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecVecFloat___setitem__(self, *args)

    def pop(self) -> "std::vector< std::vector< float > >::value_type":
        return _cstl.VecVecFloat_pop(self)

    def append(self, x: "VecFloat") -> "void":
        return _cstl.VecVecFloat_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecVecFloat_empty(self)

    def size(self) -> "std::vector< std::vector< float > >::size_type":
        return _cstl.VecVecFloat_size(self)

    def swap(self, v: "VecVecFloat") -> "void":
        return _cstl.VecVecFloat_swap(self, v)

    def begin(self) -> "std::vector< std::vector< float > >::iterator":
        return _cstl.VecVecFloat_begin(self)

    def end(self) -> "std::vector< std::vector< float > >::iterator":
        return _cstl.VecVecFloat_end(self)

    def rbegin(self) -> "std::vector< std::vector< float > >::reverse_iterator":
        return _cstl.VecVecFloat_rbegin(self)

    def rend(self) -> "std::vector< std::vector< float > >::reverse_iterator":
        return _cstl.VecVecFloat_rend(self)

    def clear(self) -> "void":
        return _cstl.VecVecFloat_clear(self)

    def get_allocator(self) -> "std::vector< std::vector< float > >::allocator_type":
        return _cstl.VecVecFloat_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecVecFloat_pop_back(self)

    def erase(self, *args) -> "std::vector< std::vector< float > >::iterator":
        return _cstl.VecVecFloat_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecVecFloat_swiginit(self, _cstl.new_VecVecFloat(*args))

    def push_back(self, x: "VecFloat") -> "void":
        return _cstl.VecVecFloat_push_back(self, x)

    def front(self) -> "std::vector< std::vector< float > >::value_type const &":
        return _cstl.VecVecFloat_front(self)

    def back(self) -> "std::vector< std::vector< float > >::value_type const &":
        return _cstl.VecVecFloat_back(self)

    def assign(self, n: "std::vector< std::vector< float > >::size_type", x: "VecFloat") -> "void":
        return _cstl.VecVecFloat_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecVecFloat_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecVecFloat_insert(self, *args)

    def reserve(self, n: "std::vector< std::vector< float > >::size_type") -> "void":
        return _cstl.VecVecFloat_reserve(self, n)

    def capacity(self) -> "std::vector< std::vector< float > >::size_type":
        return _cstl.VecVecFloat_capacity(self)
    __swig_destroy__ = _cstl.delete_VecVecFloat

# Register VecVecFloat in _cstl:
_cstl.VecVecFloat_swigregister(VecVecFloat)

class VecVecDouble(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecVecDouble_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecVecDouble___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecVecDouble___bool__(self)

    def __len__(self) -> "std::vector< std::vector< double > >::size_type":
        return _cstl.VecVecDouble___len__(self)

    def __getslice__(self, i: "std::vector< std::vector< double > >::difference_type", j: "std::vector< std::vector< double > >::difference_type") -> "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *":
        return _cstl.VecVecDouble___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecVecDouble___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::vector< double > >::difference_type", j: "std::vector< std::vector< double > >::difference_type") -> "void":
        return _cstl.VecVecDouble___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecVecDouble___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::vector< double > >::value_type const &":
        return _cstl.VecVecDouble___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecVecDouble___setitem__(self, *args)

    def pop(self) -> "std::vector< std::vector< double > >::value_type":
        return _cstl.VecVecDouble_pop(self)

    def append(self, x: "VecDouble") -> "void":
        return _cstl.VecVecDouble_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecVecDouble_empty(self)

    def size(self) -> "std::vector< std::vector< double > >::size_type":
        return _cstl.VecVecDouble_size(self)

    def swap(self, v: "VecVecDouble") -> "void":
        return _cstl.VecVecDouble_swap(self, v)

    def begin(self) -> "std::vector< std::vector< double > >::iterator":
        return _cstl.VecVecDouble_begin(self)

    def end(self) -> "std::vector< std::vector< double > >::iterator":
        return _cstl.VecVecDouble_end(self)

    def rbegin(self) -> "std::vector< std::vector< double > >::reverse_iterator":
        return _cstl.VecVecDouble_rbegin(self)

    def rend(self) -> "std::vector< std::vector< double > >::reverse_iterator":
        return _cstl.VecVecDouble_rend(self)

    def clear(self) -> "void":
        return _cstl.VecVecDouble_clear(self)

    def get_allocator(self) -> "std::vector< std::vector< double > >::allocator_type":
        return _cstl.VecVecDouble_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecVecDouble_pop_back(self)

    def erase(self, *args) -> "std::vector< std::vector< double > >::iterator":
        return _cstl.VecVecDouble_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecVecDouble_swiginit(self, _cstl.new_VecVecDouble(*args))

    def push_back(self, x: "VecDouble") -> "void":
        return _cstl.VecVecDouble_push_back(self, x)

    def front(self) -> "std::vector< std::vector< double > >::value_type const &":
        return _cstl.VecVecDouble_front(self)

    def back(self) -> "std::vector< std::vector< double > >::value_type const &":
        return _cstl.VecVecDouble_back(self)

    def assign(self, n: "std::vector< std::vector< double > >::size_type", x: "VecDouble") -> "void":
        return _cstl.VecVecDouble_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecVecDouble_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecVecDouble_insert(self, *args)

    def reserve(self, n: "std::vector< std::vector< double > >::size_type") -> "void":
        return _cstl.VecVecDouble_reserve(self, n)

    def capacity(self) -> "std::vector< std::vector< double > >::size_type":
        return _cstl.VecVecDouble_capacity(self)
    __swig_destroy__ = _cstl.delete_VecVecDouble

# Register VecVecDouble in _cstl:
_cstl.VecVecDouble_swigregister(VecVecDouble)

class VecVecBool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecVecBool_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecVecBool___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecVecBool___bool__(self)

    def __len__(self) -> "std::vector< std::vector< bool > >::size_type":
        return _cstl.VecVecBool___len__(self)

    def __getslice__(self, i: "std::vector< std::vector< bool > >::difference_type", j: "std::vector< std::vector< bool > >::difference_type") -> "std::vector< std::vector< bool,std::allocator< bool > >,std::allocator< std::vector< bool,std::allocator< bool > > > > *":
        return _cstl.VecVecBool___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecVecBool___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::vector< bool > >::difference_type", j: "std::vector< std::vector< bool > >::difference_type") -> "void":
        return _cstl.VecVecBool___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecVecBool___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::vector< bool > >::value_type const &":
        return _cstl.VecVecBool___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecVecBool___setitem__(self, *args)

    def pop(self) -> "std::vector< std::vector< bool > >::value_type":
        return _cstl.VecVecBool_pop(self)

    def append(self, x: "VecBool") -> "void":
        return _cstl.VecVecBool_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecVecBool_empty(self)

    def size(self) -> "std::vector< std::vector< bool > >::size_type":
        return _cstl.VecVecBool_size(self)

    def swap(self, v: "VecVecBool") -> "void":
        return _cstl.VecVecBool_swap(self, v)

    def begin(self) -> "std::vector< std::vector< bool > >::iterator":
        return _cstl.VecVecBool_begin(self)

    def end(self) -> "std::vector< std::vector< bool > >::iterator":
        return _cstl.VecVecBool_end(self)

    def rbegin(self) -> "std::vector< std::vector< bool > >::reverse_iterator":
        return _cstl.VecVecBool_rbegin(self)

    def rend(self) -> "std::vector< std::vector< bool > >::reverse_iterator":
        return _cstl.VecVecBool_rend(self)

    def clear(self) -> "void":
        return _cstl.VecVecBool_clear(self)

    def get_allocator(self) -> "std::vector< std::vector< bool > >::allocator_type":
        return _cstl.VecVecBool_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecVecBool_pop_back(self)

    def erase(self, *args) -> "std::vector< std::vector< bool > >::iterator":
        return _cstl.VecVecBool_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecVecBool_swiginit(self, _cstl.new_VecVecBool(*args))

    def push_back(self, x: "VecBool") -> "void":
        return _cstl.VecVecBool_push_back(self, x)

    def front(self) -> "std::vector< std::vector< bool > >::value_type const &":
        return _cstl.VecVecBool_front(self)

    def back(self) -> "std::vector< std::vector< bool > >::value_type const &":
        return _cstl.VecVecBool_back(self)

    def assign(self, n: "std::vector< std::vector< bool > >::size_type", x: "VecBool") -> "void":
        return _cstl.VecVecBool_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecVecBool_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecVecBool_insert(self, *args)

    def reserve(self, n: "std::vector< std::vector< bool > >::size_type") -> "void":
        return _cstl.VecVecBool_reserve(self, n)

    def capacity(self) -> "std::vector< std::vector< bool > >::size_type":
        return _cstl.VecVecBool_capacity(self)
    __swig_destroy__ = _cstl.delete_VecVecBool

# Register VecVecBool in _cstl:
_cstl.VecVecBool_swigregister(VecVecBool)

class VecVecLong(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecVecLong_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecVecLong___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecVecLong___bool__(self)

    def __len__(self) -> "std::vector< std::vector< std::int64_t > >::size_type":
        return _cstl.VecVecLong___len__(self)

    def __getslice__(self, i: "std::vector< std::vector< std::int64_t > >::difference_type", j: "std::vector< std::vector< std::int64_t > >::difference_type") -> "std::vector< std::vector< std::int64_t,std::allocator< std::int64_t > >,std::allocator< std::vector< std::int64_t,std::allocator< std::int64_t > > > > *":
        return _cstl.VecVecLong___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecVecLong___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::vector< std::int64_t > >::difference_type", j: "std::vector< std::vector< std::int64_t > >::difference_type") -> "void":
        return _cstl.VecVecLong___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecVecLong___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::vector< std::int64_t > >::value_type const &":
        return _cstl.VecVecLong___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecVecLong___setitem__(self, *args)

    def pop(self) -> "std::vector< std::vector< std::int64_t > >::value_type":
        return _cstl.VecVecLong_pop(self)

    def append(self, x: "VecLong") -> "void":
        return _cstl.VecVecLong_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecVecLong_empty(self)

    def size(self) -> "std::vector< std::vector< std::int64_t > >::size_type":
        return _cstl.VecVecLong_size(self)

    def swap(self, v: "VecVecLong") -> "void":
        return _cstl.VecVecLong_swap(self, v)

    def begin(self) -> "std::vector< std::vector< std::int64_t > >::iterator":
        return _cstl.VecVecLong_begin(self)

    def end(self) -> "std::vector< std::vector< std::int64_t > >::iterator":
        return _cstl.VecVecLong_end(self)

    def rbegin(self) -> "std::vector< std::vector< std::int64_t > >::reverse_iterator":
        return _cstl.VecVecLong_rbegin(self)

    def rend(self) -> "std::vector< std::vector< std::int64_t > >::reverse_iterator":
        return _cstl.VecVecLong_rend(self)

    def clear(self) -> "void":
        return _cstl.VecVecLong_clear(self)

    def get_allocator(self) -> "std::vector< std::vector< std::int64_t > >::allocator_type":
        return _cstl.VecVecLong_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecVecLong_pop_back(self)

    def erase(self, *args) -> "std::vector< std::vector< std::int64_t > >::iterator":
        return _cstl.VecVecLong_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecVecLong_swiginit(self, _cstl.new_VecVecLong(*args))

    def push_back(self, x: "VecLong") -> "void":
        return _cstl.VecVecLong_push_back(self, x)

    def front(self) -> "std::vector< std::vector< std::int64_t > >::value_type const &":
        return _cstl.VecVecLong_front(self)

    def back(self) -> "std::vector< std::vector< std::int64_t > >::value_type const &":
        return _cstl.VecVecLong_back(self)

    def assign(self, n: "std::vector< std::vector< std::int64_t > >::size_type", x: "VecLong") -> "void":
        return _cstl.VecVecLong_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecVecLong_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecVecLong_insert(self, *args)

    def reserve(self, n: "std::vector< std::vector< std::int64_t > >::size_type") -> "void":
        return _cstl.VecVecLong_reserve(self, n)

    def capacity(self) -> "std::vector< std::vector< std::int64_t > >::size_type":
        return _cstl.VecVecLong_capacity(self)
    __swig_destroy__ = _cstl.delete_VecVecLong

# Register VecVecLong in _cstl:
_cstl.VecVecLong_swigregister(VecVecLong)

class VecSetInt(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecSetInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecSetInt___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecSetInt___bool__(self)

    def __len__(self) -> "std::vector< std::unordered_set< int > >::size_type":
        return _cstl.VecSetInt___len__(self)

    def __getslice__(self, i: "std::vector< std::unordered_set< int > >::difference_type", j: "std::vector< std::unordered_set< int > >::difference_type") -> "std::vector< std::unordered_set< int,std::hash< int >,std::equal_to< int >,std::allocator< int > >,std::allocator< std::unordered_set< int,std::hash< int >,std::equal_to< int >,std::allocator< int > > > > *":
        return _cstl.VecSetInt___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecSetInt___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::unordered_set< int > >::difference_type", j: "std::vector< std::unordered_set< int > >::difference_type") -> "void":
        return _cstl.VecSetInt___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecSetInt___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::unordered_set< int > >::value_type const &":
        return _cstl.VecSetInt___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecSetInt___setitem__(self, *args)

    def pop(self) -> "std::vector< std::unordered_set< int > >::value_type":
        return _cstl.VecSetInt_pop(self)

    def append(self, x: "SetInt") -> "void":
        return _cstl.VecSetInt_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecSetInt_empty(self)

    def size(self) -> "std::vector< std::unordered_set< int > >::size_type":
        return _cstl.VecSetInt_size(self)

    def swap(self, v: "VecSetInt") -> "void":
        return _cstl.VecSetInt_swap(self, v)

    def begin(self) -> "std::vector< std::unordered_set< int > >::iterator":
        return _cstl.VecSetInt_begin(self)

    def end(self) -> "std::vector< std::unordered_set< int > >::iterator":
        return _cstl.VecSetInt_end(self)

    def rbegin(self) -> "std::vector< std::unordered_set< int > >::reverse_iterator":
        return _cstl.VecSetInt_rbegin(self)

    def rend(self) -> "std::vector< std::unordered_set< int > >::reverse_iterator":
        return _cstl.VecSetInt_rend(self)

    def clear(self) -> "void":
        return _cstl.VecSetInt_clear(self)

    def get_allocator(self) -> "std::vector< std::unordered_set< int > >::allocator_type":
        return _cstl.VecSetInt_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecSetInt_pop_back(self)

    def erase(self, *args) -> "std::vector< std::unordered_set< int > >::iterator":
        return _cstl.VecSetInt_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecSetInt_swiginit(self, _cstl.new_VecSetInt(*args))

    def push_back(self, x: "SetInt") -> "void":
        return _cstl.VecSetInt_push_back(self, x)

    def front(self) -> "std::vector< std::unordered_set< int > >::value_type const &":
        return _cstl.VecSetInt_front(self)

    def back(self) -> "std::vector< std::unordered_set< int > >::value_type const &":
        return _cstl.VecSetInt_back(self)

    def assign(self, n: "std::vector< std::unordered_set< int > >::size_type", x: "SetInt") -> "void":
        return _cstl.VecSetInt_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecSetInt_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecSetInt_insert(self, *args)

    def reserve(self, n: "std::vector< std::unordered_set< int > >::size_type") -> "void":
        return _cstl.VecSetInt_reserve(self, n)

    def capacity(self) -> "std::vector< std::unordered_set< int > >::size_type":
        return _cstl.VecSetInt_capacity(self)
    __swig_destroy__ = _cstl.delete_VecSetInt

# Register VecSetInt in _cstl:
_cstl.VecSetInt_swigregister(VecSetInt)

class VecSetStr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecSetStr_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecSetStr___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecSetStr___bool__(self)

    def __len__(self) -> "std::vector< std::unordered_set< std::string > >::size_type":
        return _cstl.VecSetStr___len__(self)

    def __getslice__(self, i: "std::vector< std::unordered_set< std::string > >::difference_type", j: "std::vector< std::unordered_set< std::string > >::difference_type") -> "std::vector< std::unordered_set< std::string,std::hash< std::string >,std::equal_to< std::string >,std::allocator< std::string > >,std::allocator< std::unordered_set< std::string,std::hash< std::string >,std::equal_to< std::string >,std::allocator< std::string > > > > *":
        return _cstl.VecSetStr___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecSetStr___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::unordered_set< std::string > >::difference_type", j: "std::vector< std::unordered_set< std::string > >::difference_type") -> "void":
        return _cstl.VecSetStr___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecSetStr___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::unordered_set< std::string > >::value_type const &":
        return _cstl.VecSetStr___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecSetStr___setitem__(self, *args)

    def pop(self) -> "std::vector< std::unordered_set< std::string > >::value_type":
        return _cstl.VecSetStr_pop(self)

    def append(self, x: "SetStr") -> "void":
        return _cstl.VecSetStr_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecSetStr_empty(self)

    def size(self) -> "std::vector< std::unordered_set< std::string > >::size_type":
        return _cstl.VecSetStr_size(self)

    def swap(self, v: "VecSetStr") -> "void":
        return _cstl.VecSetStr_swap(self, v)

    def begin(self) -> "std::vector< std::unordered_set< std::string > >::iterator":
        return _cstl.VecSetStr_begin(self)

    def end(self) -> "std::vector< std::unordered_set< std::string > >::iterator":
        return _cstl.VecSetStr_end(self)

    def rbegin(self) -> "std::vector< std::unordered_set< std::string > >::reverse_iterator":
        return _cstl.VecSetStr_rbegin(self)

    def rend(self) -> "std::vector< std::unordered_set< std::string > >::reverse_iterator":
        return _cstl.VecSetStr_rend(self)

    def clear(self) -> "void":
        return _cstl.VecSetStr_clear(self)

    def get_allocator(self) -> "std::vector< std::unordered_set< std::string > >::allocator_type":
        return _cstl.VecSetStr_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecSetStr_pop_back(self)

    def erase(self, *args) -> "std::vector< std::unordered_set< std::string > >::iterator":
        return _cstl.VecSetStr_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecSetStr_swiginit(self, _cstl.new_VecSetStr(*args))

    def push_back(self, x: "SetStr") -> "void":
        return _cstl.VecSetStr_push_back(self, x)

    def front(self) -> "std::vector< std::unordered_set< std::string > >::value_type const &":
        return _cstl.VecSetStr_front(self)

    def back(self) -> "std::vector< std::unordered_set< std::string > >::value_type const &":
        return _cstl.VecSetStr_back(self)

    def assign(self, n: "std::vector< std::unordered_set< std::string > >::size_type", x: "SetStr") -> "void":
        return _cstl.VecSetStr_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecSetStr_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecSetStr_insert(self, *args)

    def reserve(self, n: "std::vector< std::unordered_set< std::string > >::size_type") -> "void":
        return _cstl.VecSetStr_reserve(self, n)

    def capacity(self) -> "std::vector< std::unordered_set< std::string > >::size_type":
        return _cstl.VecSetStr_capacity(self)
    __swig_destroy__ = _cstl.delete_VecSetStr

# Register VecSetStr in _cstl:
_cstl.VecSetStr_swigregister(VecSetStr)

class VecSetLong(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecSetLong_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecSetLong___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecSetLong___bool__(self)

    def __len__(self) -> "std::vector< std::unordered_set< std::int64_t > >::size_type":
        return _cstl.VecSetLong___len__(self)

    def __getslice__(self, i: "std::vector< std::unordered_set< std::int64_t > >::difference_type", j: "std::vector< std::unordered_set< std::int64_t > >::difference_type") -> "std::vector< std::unordered_set< std::int64_t,std::hash< std::int64_t >,std::equal_to< std::int64_t >,std::allocator< std::int64_t > >,std::allocator< std::unordered_set< std::int64_t,std::hash< std::int64_t >,std::equal_to< std::int64_t >,std::allocator< std::int64_t > > > > *":
        return _cstl.VecSetLong___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecSetLong___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::unordered_set< std::int64_t > >::difference_type", j: "std::vector< std::unordered_set< std::int64_t > >::difference_type") -> "void":
        return _cstl.VecSetLong___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecSetLong___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::unordered_set< std::int64_t > >::value_type const &":
        return _cstl.VecSetLong___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecSetLong___setitem__(self, *args)

    def pop(self) -> "std::vector< std::unordered_set< std::int64_t > >::value_type":
        return _cstl.VecSetLong_pop(self)

    def append(self, x: "SetLong") -> "void":
        return _cstl.VecSetLong_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecSetLong_empty(self)

    def size(self) -> "std::vector< std::unordered_set< std::int64_t > >::size_type":
        return _cstl.VecSetLong_size(self)

    def swap(self, v: "VecSetLong") -> "void":
        return _cstl.VecSetLong_swap(self, v)

    def begin(self) -> "std::vector< std::unordered_set< std::int64_t > >::iterator":
        return _cstl.VecSetLong_begin(self)

    def end(self) -> "std::vector< std::unordered_set< std::int64_t > >::iterator":
        return _cstl.VecSetLong_end(self)

    def rbegin(self) -> "std::vector< std::unordered_set< std::int64_t > >::reverse_iterator":
        return _cstl.VecSetLong_rbegin(self)

    def rend(self) -> "std::vector< std::unordered_set< std::int64_t > >::reverse_iterator":
        return _cstl.VecSetLong_rend(self)

    def clear(self) -> "void":
        return _cstl.VecSetLong_clear(self)

    def get_allocator(self) -> "std::vector< std::unordered_set< std::int64_t > >::allocator_type":
        return _cstl.VecSetLong_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecSetLong_pop_back(self)

    def erase(self, *args) -> "std::vector< std::unordered_set< std::int64_t > >::iterator":
        return _cstl.VecSetLong_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecSetLong_swiginit(self, _cstl.new_VecSetLong(*args))

    def push_back(self, x: "SetLong") -> "void":
        return _cstl.VecSetLong_push_back(self, x)

    def front(self) -> "std::vector< std::unordered_set< std::int64_t > >::value_type const &":
        return _cstl.VecSetLong_front(self)

    def back(self) -> "std::vector< std::unordered_set< std::int64_t > >::value_type const &":
        return _cstl.VecSetLong_back(self)

    def assign(self, n: "std::vector< std::unordered_set< std::int64_t > >::size_type", x: "SetLong") -> "void":
        return _cstl.VecSetLong_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecSetLong_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecSetLong_insert(self, *args)

    def reserve(self, n: "std::vector< std::unordered_set< std::int64_t > >::size_type") -> "void":
        return _cstl.VecSetLong_reserve(self, n)

    def capacity(self) -> "std::vector< std::unordered_set< std::int64_t > >::size_type":
        return _cstl.VecSetLong_capacity(self)
    __swig_destroy__ = _cstl.delete_VecSetLong

# Register VecSetLong in _cstl:
_cstl.VecSetLong_swigregister(VecSetLong)

class VecMapIntInt(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecMapIntInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecMapIntInt___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecMapIntInt___bool__(self)

    def __len__(self) -> "std::vector< std::unordered_map< int,int > >::size_type":
        return _cstl.VecMapIntInt___len__(self)

    def __getslice__(self, i: "std::vector< std::unordered_map< int,int > >::difference_type", j: "std::vector< std::unordered_map< int,int > >::difference_type") -> "std::vector< std::unordered_map< int,int,std::hash< int >,std::equal_to< int >,std::allocator< std::pair< int const,int > > >,std::allocator< std::unordered_map< int,int,std::hash< int >,std::equal_to< int >,std::allocator< std::pair< int const,int > > > > > *":
        return _cstl.VecMapIntInt___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecMapIntInt___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::unordered_map< int,int > >::difference_type", j: "std::vector< std::unordered_map< int,int > >::difference_type") -> "void":
        return _cstl.VecMapIntInt___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecMapIntInt___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::unordered_map< int,int > >::value_type const &":
        return _cstl.VecMapIntInt___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecMapIntInt___setitem__(self, *args)

    def pop(self) -> "std::vector< std::unordered_map< int,int > >::value_type":
        return _cstl.VecMapIntInt_pop(self)

    def append(self, x: "MapIntInt") -> "void":
        return _cstl.VecMapIntInt_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecMapIntInt_empty(self)

    def size(self) -> "std::vector< std::unordered_map< int,int > >::size_type":
        return _cstl.VecMapIntInt_size(self)

    def swap(self, v: "VecMapIntInt") -> "void":
        return _cstl.VecMapIntInt_swap(self, v)

    def begin(self) -> "std::vector< std::unordered_map< int,int > >::iterator":
        return _cstl.VecMapIntInt_begin(self)

    def end(self) -> "std::vector< std::unordered_map< int,int > >::iterator":
        return _cstl.VecMapIntInt_end(self)

    def rbegin(self) -> "std::vector< std::unordered_map< int,int > >::reverse_iterator":
        return _cstl.VecMapIntInt_rbegin(self)

    def rend(self) -> "std::vector< std::unordered_map< int,int > >::reverse_iterator":
        return _cstl.VecMapIntInt_rend(self)

    def clear(self) -> "void":
        return _cstl.VecMapIntInt_clear(self)

    def get_allocator(self) -> "std::vector< std::unordered_map< int,int > >::allocator_type":
        return _cstl.VecMapIntInt_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecMapIntInt_pop_back(self)

    def erase(self, *args) -> "std::vector< std::unordered_map< int,int > >::iterator":
        return _cstl.VecMapIntInt_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecMapIntInt_swiginit(self, _cstl.new_VecMapIntInt(*args))

    def push_back(self, x: "MapIntInt") -> "void":
        return _cstl.VecMapIntInt_push_back(self, x)

    def front(self) -> "std::vector< std::unordered_map< int,int > >::value_type const &":
        return _cstl.VecMapIntInt_front(self)

    def back(self) -> "std::vector< std::unordered_map< int,int > >::value_type const &":
        return _cstl.VecMapIntInt_back(self)

    def assign(self, n: "std::vector< std::unordered_map< int,int > >::size_type", x: "MapIntInt") -> "void":
        return _cstl.VecMapIntInt_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecMapIntInt_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecMapIntInt_insert(self, *args)

    def reserve(self, n: "std::vector< std::unordered_map< int,int > >::size_type") -> "void":
        return _cstl.VecMapIntInt_reserve(self, n)

    def capacity(self) -> "std::vector< std::unordered_map< int,int > >::size_type":
        return _cstl.VecMapIntInt_capacity(self)
    __swig_destroy__ = _cstl.delete_VecMapIntInt

# Register VecMapIntInt in _cstl:
_cstl.VecMapIntInt_swigregister(VecMapIntInt)

class VecMapIntStr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecMapIntStr_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecMapIntStr___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecMapIntStr___bool__(self)

    def __len__(self) -> "std::vector< std::unordered_map< int,std::string > >::size_type":
        return _cstl.VecMapIntStr___len__(self)

    def __getslice__(self, i: "std::vector< std::unordered_map< int,std::string > >::difference_type", j: "std::vector< std::unordered_map< int,std::string > >::difference_type") -> "std::vector< std::unordered_map< int,std::string,std::hash< int >,std::equal_to< int >,std::allocator< std::pair< int const,std::string > > >,std::allocator< std::unordered_map< int,std::string,std::hash< int >,std::equal_to< int >,std::allocator< std::pair< int const,std::string > > > > > *":
        return _cstl.VecMapIntStr___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecMapIntStr___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::unordered_map< int,std::string > >::difference_type", j: "std::vector< std::unordered_map< int,std::string > >::difference_type") -> "void":
        return _cstl.VecMapIntStr___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecMapIntStr___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::unordered_map< int,std::string > >::value_type const &":
        return _cstl.VecMapIntStr___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecMapIntStr___setitem__(self, *args)

    def pop(self) -> "std::vector< std::unordered_map< int,std::string > >::value_type":
        return _cstl.VecMapIntStr_pop(self)

    def append(self, x: "MapIntStr") -> "void":
        return _cstl.VecMapIntStr_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecMapIntStr_empty(self)

    def size(self) -> "std::vector< std::unordered_map< int,std::string > >::size_type":
        return _cstl.VecMapIntStr_size(self)

    def swap(self, v: "VecMapIntStr") -> "void":
        return _cstl.VecMapIntStr_swap(self, v)

    def begin(self) -> "std::vector< std::unordered_map< int,std::string > >::iterator":
        return _cstl.VecMapIntStr_begin(self)

    def end(self) -> "std::vector< std::unordered_map< int,std::string > >::iterator":
        return _cstl.VecMapIntStr_end(self)

    def rbegin(self) -> "std::vector< std::unordered_map< int,std::string > >::reverse_iterator":
        return _cstl.VecMapIntStr_rbegin(self)

    def rend(self) -> "std::vector< std::unordered_map< int,std::string > >::reverse_iterator":
        return _cstl.VecMapIntStr_rend(self)

    def clear(self) -> "void":
        return _cstl.VecMapIntStr_clear(self)

    def get_allocator(self) -> "std::vector< std::unordered_map< int,std::string > >::allocator_type":
        return _cstl.VecMapIntStr_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecMapIntStr_pop_back(self)

    def erase(self, *args) -> "std::vector< std::unordered_map< int,std::string > >::iterator":
        return _cstl.VecMapIntStr_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecMapIntStr_swiginit(self, _cstl.new_VecMapIntStr(*args))

    def push_back(self, x: "MapIntStr") -> "void":
        return _cstl.VecMapIntStr_push_back(self, x)

    def front(self) -> "std::vector< std::unordered_map< int,std::string > >::value_type const &":
        return _cstl.VecMapIntStr_front(self)

    def back(self) -> "std::vector< std::unordered_map< int,std::string > >::value_type const &":
        return _cstl.VecMapIntStr_back(self)

    def assign(self, n: "std::vector< std::unordered_map< int,std::string > >::size_type", x: "MapIntStr") -> "void":
        return _cstl.VecMapIntStr_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecMapIntStr_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecMapIntStr_insert(self, *args)

    def reserve(self, n: "std::vector< std::unordered_map< int,std::string > >::size_type") -> "void":
        return _cstl.VecMapIntStr_reserve(self, n)

    def capacity(self) -> "std::vector< std::unordered_map< int,std::string > >::size_type":
        return _cstl.VecMapIntStr_capacity(self)
    __swig_destroy__ = _cstl.delete_VecMapIntStr

# Register VecMapIntStr in _cstl:
_cstl.VecMapIntStr_swigregister(VecMapIntStr)

class VecMapIntFloat(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecMapIntFloat_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecMapIntFloat___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecMapIntFloat___bool__(self)

    def __len__(self) -> "std::vector< std::unordered_map< int,float > >::size_type":
        return _cstl.VecMapIntFloat___len__(self)

    def __getslice__(self, i: "std::vector< std::unordered_map< int,float > >::difference_type", j: "std::vector< std::unordered_map< int,float > >::difference_type") -> "std::vector< std::unordered_map< int,float,std::hash< int >,std::equal_to< int >,std::allocator< std::pair< int const,float > > >,std::allocator< std::unordered_map< int,float,std::hash< int >,std::equal_to< int >,std::allocator< std::pair< int const,float > > > > > *":
        return _cstl.VecMapIntFloat___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecMapIntFloat___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::unordered_map< int,float > >::difference_type", j: "std::vector< std::unordered_map< int,float > >::difference_type") -> "void":
        return _cstl.VecMapIntFloat___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecMapIntFloat___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::unordered_map< int,float > >::value_type const &":
        return _cstl.VecMapIntFloat___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecMapIntFloat___setitem__(self, *args)

    def pop(self) -> "std::vector< std::unordered_map< int,float > >::value_type":
        return _cstl.VecMapIntFloat_pop(self)

    def append(self, x: "MapIntFloat") -> "void":
        return _cstl.VecMapIntFloat_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecMapIntFloat_empty(self)

    def size(self) -> "std::vector< std::unordered_map< int,float > >::size_type":
        return _cstl.VecMapIntFloat_size(self)

    def swap(self, v: "VecMapIntFloat") -> "void":
        return _cstl.VecMapIntFloat_swap(self, v)

    def begin(self) -> "std::vector< std::unordered_map< int,float > >::iterator":
        return _cstl.VecMapIntFloat_begin(self)

    def end(self) -> "std::vector< std::unordered_map< int,float > >::iterator":
        return _cstl.VecMapIntFloat_end(self)

    def rbegin(self) -> "std::vector< std::unordered_map< int,float > >::reverse_iterator":
        return _cstl.VecMapIntFloat_rbegin(self)

    def rend(self) -> "std::vector< std::unordered_map< int,float > >::reverse_iterator":
        return _cstl.VecMapIntFloat_rend(self)

    def clear(self) -> "void":
        return _cstl.VecMapIntFloat_clear(self)

    def get_allocator(self) -> "std::vector< std::unordered_map< int,float > >::allocator_type":
        return _cstl.VecMapIntFloat_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecMapIntFloat_pop_back(self)

    def erase(self, *args) -> "std::vector< std::unordered_map< int,float > >::iterator":
        return _cstl.VecMapIntFloat_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecMapIntFloat_swiginit(self, _cstl.new_VecMapIntFloat(*args))

    def push_back(self, x: "MapIntFloat") -> "void":
        return _cstl.VecMapIntFloat_push_back(self, x)

    def front(self) -> "std::vector< std::unordered_map< int,float > >::value_type const &":
        return _cstl.VecMapIntFloat_front(self)

    def back(self) -> "std::vector< std::unordered_map< int,float > >::value_type const &":
        return _cstl.VecMapIntFloat_back(self)

    def assign(self, n: "std::vector< std::unordered_map< int,float > >::size_type", x: "MapIntFloat") -> "void":
        return _cstl.VecMapIntFloat_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecMapIntFloat_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecMapIntFloat_insert(self, *args)

    def reserve(self, n: "std::vector< std::unordered_map< int,float > >::size_type") -> "void":
        return _cstl.VecMapIntFloat_reserve(self, n)

    def capacity(self) -> "std::vector< std::unordered_map< int,float > >::size_type":
        return _cstl.VecMapIntFloat_capacity(self)
    __swig_destroy__ = _cstl.delete_VecMapIntFloat

# Register VecMapIntFloat in _cstl:
_cstl.VecMapIntFloat_swigregister(VecMapIntFloat)

class VecMapIntDouble(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecMapIntDouble_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecMapIntDouble___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecMapIntDouble___bool__(self)

    def __len__(self) -> "std::vector< std::unordered_map< int,double > >::size_type":
        return _cstl.VecMapIntDouble___len__(self)

    def __getslice__(self, i: "std::vector< std::unordered_map< int,double > >::difference_type", j: "std::vector< std::unordered_map< int,double > >::difference_type") -> "std::vector< std::unordered_map< int,double,std::hash< int >,std::equal_to< int >,std::allocator< std::pair< int const,double > > >,std::allocator< std::unordered_map< int,double,std::hash< int >,std::equal_to< int >,std::allocator< std::pair< int const,double > > > > > *":
        return _cstl.VecMapIntDouble___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecMapIntDouble___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::unordered_map< int,double > >::difference_type", j: "std::vector< std::unordered_map< int,double > >::difference_type") -> "void":
        return _cstl.VecMapIntDouble___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecMapIntDouble___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::unordered_map< int,double > >::value_type const &":
        return _cstl.VecMapIntDouble___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecMapIntDouble___setitem__(self, *args)

    def pop(self) -> "std::vector< std::unordered_map< int,double > >::value_type":
        return _cstl.VecMapIntDouble_pop(self)

    def append(self, x: "MapIntDouble") -> "void":
        return _cstl.VecMapIntDouble_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecMapIntDouble_empty(self)

    def size(self) -> "std::vector< std::unordered_map< int,double > >::size_type":
        return _cstl.VecMapIntDouble_size(self)

    def swap(self, v: "VecMapIntDouble") -> "void":
        return _cstl.VecMapIntDouble_swap(self, v)

    def begin(self) -> "std::vector< std::unordered_map< int,double > >::iterator":
        return _cstl.VecMapIntDouble_begin(self)

    def end(self) -> "std::vector< std::unordered_map< int,double > >::iterator":
        return _cstl.VecMapIntDouble_end(self)

    def rbegin(self) -> "std::vector< std::unordered_map< int,double > >::reverse_iterator":
        return _cstl.VecMapIntDouble_rbegin(self)

    def rend(self) -> "std::vector< std::unordered_map< int,double > >::reverse_iterator":
        return _cstl.VecMapIntDouble_rend(self)

    def clear(self) -> "void":
        return _cstl.VecMapIntDouble_clear(self)

    def get_allocator(self) -> "std::vector< std::unordered_map< int,double > >::allocator_type":
        return _cstl.VecMapIntDouble_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecMapIntDouble_pop_back(self)

    def erase(self, *args) -> "std::vector< std::unordered_map< int,double > >::iterator":
        return _cstl.VecMapIntDouble_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecMapIntDouble_swiginit(self, _cstl.new_VecMapIntDouble(*args))

    def push_back(self, x: "MapIntDouble") -> "void":
        return _cstl.VecMapIntDouble_push_back(self, x)

    def front(self) -> "std::vector< std::unordered_map< int,double > >::value_type const &":
        return _cstl.VecMapIntDouble_front(self)

    def back(self) -> "std::vector< std::unordered_map< int,double > >::value_type const &":
        return _cstl.VecMapIntDouble_back(self)

    def assign(self, n: "std::vector< std::unordered_map< int,double > >::size_type", x: "MapIntDouble") -> "void":
        return _cstl.VecMapIntDouble_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecMapIntDouble_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecMapIntDouble_insert(self, *args)

    def reserve(self, n: "std::vector< std::unordered_map< int,double > >::size_type") -> "void":
        return _cstl.VecMapIntDouble_reserve(self, n)

    def capacity(self) -> "std::vector< std::unordered_map< int,double > >::size_type":
        return _cstl.VecMapIntDouble_capacity(self)
    __swig_destroy__ = _cstl.delete_VecMapIntDouble

# Register VecMapIntDouble in _cstl:
_cstl.VecMapIntDouble_swigregister(VecMapIntDouble)

class VecMapIntBool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecMapIntBool_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecMapIntBool___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecMapIntBool___bool__(self)

    def __len__(self) -> "std::vector< std::unordered_map< int,bool > >::size_type":
        return _cstl.VecMapIntBool___len__(self)

    def __getslice__(self, i: "std::vector< std::unordered_map< int,bool > >::difference_type", j: "std::vector< std::unordered_map< int,bool > >::difference_type") -> "std::vector< std::unordered_map< int,bool,std::hash< int >,std::equal_to< int >,std::allocator< std::pair< int const,bool > > >,std::allocator< std::unordered_map< int,bool,std::hash< int >,std::equal_to< int >,std::allocator< std::pair< int const,bool > > > > > *":
        return _cstl.VecMapIntBool___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecMapIntBool___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::unordered_map< int,bool > >::difference_type", j: "std::vector< std::unordered_map< int,bool > >::difference_type") -> "void":
        return _cstl.VecMapIntBool___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecMapIntBool___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::unordered_map< int,bool > >::value_type const &":
        return _cstl.VecMapIntBool___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecMapIntBool___setitem__(self, *args)

    def pop(self) -> "std::vector< std::unordered_map< int,bool > >::value_type":
        return _cstl.VecMapIntBool_pop(self)

    def append(self, x: "MapIntBool") -> "void":
        return _cstl.VecMapIntBool_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecMapIntBool_empty(self)

    def size(self) -> "std::vector< std::unordered_map< int,bool > >::size_type":
        return _cstl.VecMapIntBool_size(self)

    def swap(self, v: "VecMapIntBool") -> "void":
        return _cstl.VecMapIntBool_swap(self, v)

    def begin(self) -> "std::vector< std::unordered_map< int,bool > >::iterator":
        return _cstl.VecMapIntBool_begin(self)

    def end(self) -> "std::vector< std::unordered_map< int,bool > >::iterator":
        return _cstl.VecMapIntBool_end(self)

    def rbegin(self) -> "std::vector< std::unordered_map< int,bool > >::reverse_iterator":
        return _cstl.VecMapIntBool_rbegin(self)

    def rend(self) -> "std::vector< std::unordered_map< int,bool > >::reverse_iterator":
        return _cstl.VecMapIntBool_rend(self)

    def clear(self) -> "void":
        return _cstl.VecMapIntBool_clear(self)

    def get_allocator(self) -> "std::vector< std::unordered_map< int,bool > >::allocator_type":
        return _cstl.VecMapIntBool_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecMapIntBool_pop_back(self)

    def erase(self, *args) -> "std::vector< std::unordered_map< int,bool > >::iterator":
        return _cstl.VecMapIntBool_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecMapIntBool_swiginit(self, _cstl.new_VecMapIntBool(*args))

    def push_back(self, x: "MapIntBool") -> "void":
        return _cstl.VecMapIntBool_push_back(self, x)

    def front(self) -> "std::vector< std::unordered_map< int,bool > >::value_type const &":
        return _cstl.VecMapIntBool_front(self)

    def back(self) -> "std::vector< std::unordered_map< int,bool > >::value_type const &":
        return _cstl.VecMapIntBool_back(self)

    def assign(self, n: "std::vector< std::unordered_map< int,bool > >::size_type", x: "MapIntBool") -> "void":
        return _cstl.VecMapIntBool_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecMapIntBool_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecMapIntBool_insert(self, *args)

    def reserve(self, n: "std::vector< std::unordered_map< int,bool > >::size_type") -> "void":
        return _cstl.VecMapIntBool_reserve(self, n)

    def capacity(self) -> "std::vector< std::unordered_map< int,bool > >::size_type":
        return _cstl.VecMapIntBool_capacity(self)
    __swig_destroy__ = _cstl.delete_VecMapIntBool

# Register VecMapIntBool in _cstl:
_cstl.VecMapIntBool_swigregister(VecMapIntBool)

class VecMapIntLong(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecMapIntLong_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecMapIntLong___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecMapIntLong___bool__(self)

    def __len__(self) -> "std::vector< std::unordered_map< int,std::int64_t > >::size_type":
        return _cstl.VecMapIntLong___len__(self)

    def __getslice__(self, i: "std::vector< std::unordered_map< int,std::int64_t > >::difference_type", j: "std::vector< std::unordered_map< int,std::int64_t > >::difference_type") -> "std::vector< std::unordered_map< int,std::int64_t,std::hash< int >,std::equal_to< int >,std::allocator< std::pair< int const,std::int64_t > > >,std::allocator< std::unordered_map< int,std::int64_t,std::hash< int >,std::equal_to< int >,std::allocator< std::pair< int const,std::int64_t > > > > > *":
        return _cstl.VecMapIntLong___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecMapIntLong___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::unordered_map< int,std::int64_t > >::difference_type", j: "std::vector< std::unordered_map< int,std::int64_t > >::difference_type") -> "void":
        return _cstl.VecMapIntLong___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecMapIntLong___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::unordered_map< int,std::int64_t > >::value_type const &":
        return _cstl.VecMapIntLong___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecMapIntLong___setitem__(self, *args)

    def pop(self) -> "std::vector< std::unordered_map< int,std::int64_t > >::value_type":
        return _cstl.VecMapIntLong_pop(self)

    def append(self, x: "MapIntLong") -> "void":
        return _cstl.VecMapIntLong_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecMapIntLong_empty(self)

    def size(self) -> "std::vector< std::unordered_map< int,std::int64_t > >::size_type":
        return _cstl.VecMapIntLong_size(self)

    def swap(self, v: "VecMapIntLong") -> "void":
        return _cstl.VecMapIntLong_swap(self, v)

    def begin(self) -> "std::vector< std::unordered_map< int,std::int64_t > >::iterator":
        return _cstl.VecMapIntLong_begin(self)

    def end(self) -> "std::vector< std::unordered_map< int,std::int64_t > >::iterator":
        return _cstl.VecMapIntLong_end(self)

    def rbegin(self) -> "std::vector< std::unordered_map< int,std::int64_t > >::reverse_iterator":
        return _cstl.VecMapIntLong_rbegin(self)

    def rend(self) -> "std::vector< std::unordered_map< int,std::int64_t > >::reverse_iterator":
        return _cstl.VecMapIntLong_rend(self)

    def clear(self) -> "void":
        return _cstl.VecMapIntLong_clear(self)

    def get_allocator(self) -> "std::vector< std::unordered_map< int,std::int64_t > >::allocator_type":
        return _cstl.VecMapIntLong_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecMapIntLong_pop_back(self)

    def erase(self, *args) -> "std::vector< std::unordered_map< int,std::int64_t > >::iterator":
        return _cstl.VecMapIntLong_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecMapIntLong_swiginit(self, _cstl.new_VecMapIntLong(*args))

    def push_back(self, x: "MapIntLong") -> "void":
        return _cstl.VecMapIntLong_push_back(self, x)

    def front(self) -> "std::vector< std::unordered_map< int,std::int64_t > >::value_type const &":
        return _cstl.VecMapIntLong_front(self)

    def back(self) -> "std::vector< std::unordered_map< int,std::int64_t > >::value_type const &":
        return _cstl.VecMapIntLong_back(self)

    def assign(self, n: "std::vector< std::unordered_map< int,std::int64_t > >::size_type", x: "MapIntLong") -> "void":
        return _cstl.VecMapIntLong_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecMapIntLong_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecMapIntLong_insert(self, *args)

    def reserve(self, n: "std::vector< std::unordered_map< int,std::int64_t > >::size_type") -> "void":
        return _cstl.VecMapIntLong_reserve(self, n)

    def capacity(self) -> "std::vector< std::unordered_map< int,std::int64_t > >::size_type":
        return _cstl.VecMapIntLong_capacity(self)
    __swig_destroy__ = _cstl.delete_VecMapIntLong

# Register VecMapIntLong in _cstl:
_cstl.VecMapIntLong_swigregister(VecMapIntLong)

class VecMapStrInt(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecMapStrInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecMapStrInt___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecMapStrInt___bool__(self)

    def __len__(self) -> "std::vector< std::unordered_map< std::string,int > >::size_type":
        return _cstl.VecMapStrInt___len__(self)

    def __getslice__(self, i: "std::vector< std::unordered_map< std::string,int > >::difference_type", j: "std::vector< std::unordered_map< std::string,int > >::difference_type") -> "std::vector< std::unordered_map< std::string,int,std::hash< std::string >,std::equal_to< std::string >,std::allocator< std::pair< std::string const,int > > >,std::allocator< std::unordered_map< std::string,int,std::hash< std::string >,std::equal_to< std::string >,std::allocator< std::pair< std::string const,int > > > > > *":
        return _cstl.VecMapStrInt___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecMapStrInt___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::unordered_map< std::string,int > >::difference_type", j: "std::vector< std::unordered_map< std::string,int > >::difference_type") -> "void":
        return _cstl.VecMapStrInt___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecMapStrInt___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::unordered_map< std::string,int > >::value_type const &":
        return _cstl.VecMapStrInt___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecMapStrInt___setitem__(self, *args)

    def pop(self) -> "std::vector< std::unordered_map< std::string,int > >::value_type":
        return _cstl.VecMapStrInt_pop(self)

    def append(self, x: "MapStrInt") -> "void":
        return _cstl.VecMapStrInt_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecMapStrInt_empty(self)

    def size(self) -> "std::vector< std::unordered_map< std::string,int > >::size_type":
        return _cstl.VecMapStrInt_size(self)

    def swap(self, v: "VecMapStrInt") -> "void":
        return _cstl.VecMapStrInt_swap(self, v)

    def begin(self) -> "std::vector< std::unordered_map< std::string,int > >::iterator":
        return _cstl.VecMapStrInt_begin(self)

    def end(self) -> "std::vector< std::unordered_map< std::string,int > >::iterator":
        return _cstl.VecMapStrInt_end(self)

    def rbegin(self) -> "std::vector< std::unordered_map< std::string,int > >::reverse_iterator":
        return _cstl.VecMapStrInt_rbegin(self)

    def rend(self) -> "std::vector< std::unordered_map< std::string,int > >::reverse_iterator":
        return _cstl.VecMapStrInt_rend(self)

    def clear(self) -> "void":
        return _cstl.VecMapStrInt_clear(self)

    def get_allocator(self) -> "std::vector< std::unordered_map< std::string,int > >::allocator_type":
        return _cstl.VecMapStrInt_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecMapStrInt_pop_back(self)

    def erase(self, *args) -> "std::vector< std::unordered_map< std::string,int > >::iterator":
        return _cstl.VecMapStrInt_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecMapStrInt_swiginit(self, _cstl.new_VecMapStrInt(*args))

    def push_back(self, x: "MapStrInt") -> "void":
        return _cstl.VecMapStrInt_push_back(self, x)

    def front(self) -> "std::vector< std::unordered_map< std::string,int > >::value_type const &":
        return _cstl.VecMapStrInt_front(self)

    def back(self) -> "std::vector< std::unordered_map< std::string,int > >::value_type const &":
        return _cstl.VecMapStrInt_back(self)

    def assign(self, n: "std::vector< std::unordered_map< std::string,int > >::size_type", x: "MapStrInt") -> "void":
        return _cstl.VecMapStrInt_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecMapStrInt_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecMapStrInt_insert(self, *args)

    def reserve(self, n: "std::vector< std::unordered_map< std::string,int > >::size_type") -> "void":
        return _cstl.VecMapStrInt_reserve(self, n)

    def capacity(self) -> "std::vector< std::unordered_map< std::string,int > >::size_type":
        return _cstl.VecMapStrInt_capacity(self)
    __swig_destroy__ = _cstl.delete_VecMapStrInt

# Register VecMapStrInt in _cstl:
_cstl.VecMapStrInt_swigregister(VecMapStrInt)

class VecMapStrStr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecMapStrStr_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecMapStrStr___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecMapStrStr___bool__(self)

    def __len__(self) -> "std::vector< std::unordered_map< std::string,std::string > >::size_type":
        return _cstl.VecMapStrStr___len__(self)

    def __getslice__(self, i: "std::vector< std::unordered_map< std::string,std::string > >::difference_type", j: "std::vector< std::unordered_map< std::string,std::string > >::difference_type") -> "std::vector< std::unordered_map< std::string,std::string,std::hash< std::string >,std::equal_to< std::string >,std::allocator< std::pair< std::string const,std::string > > >,std::allocator< std::unordered_map< std::string,std::string,std::hash< std::string >,std::equal_to< std::string >,std::allocator< std::pair< std::string const,std::string > > > > > *":
        return _cstl.VecMapStrStr___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecMapStrStr___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::unordered_map< std::string,std::string > >::difference_type", j: "std::vector< std::unordered_map< std::string,std::string > >::difference_type") -> "void":
        return _cstl.VecMapStrStr___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecMapStrStr___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::unordered_map< std::string,std::string > >::value_type const &":
        return _cstl.VecMapStrStr___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecMapStrStr___setitem__(self, *args)

    def pop(self) -> "std::vector< std::unordered_map< std::string,std::string > >::value_type":
        return _cstl.VecMapStrStr_pop(self)

    def append(self, x: "MapStrStr") -> "void":
        return _cstl.VecMapStrStr_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecMapStrStr_empty(self)

    def size(self) -> "std::vector< std::unordered_map< std::string,std::string > >::size_type":
        return _cstl.VecMapStrStr_size(self)

    def swap(self, v: "VecMapStrStr") -> "void":
        return _cstl.VecMapStrStr_swap(self, v)

    def begin(self) -> "std::vector< std::unordered_map< std::string,std::string > >::iterator":
        return _cstl.VecMapStrStr_begin(self)

    def end(self) -> "std::vector< std::unordered_map< std::string,std::string > >::iterator":
        return _cstl.VecMapStrStr_end(self)

    def rbegin(self) -> "std::vector< std::unordered_map< std::string,std::string > >::reverse_iterator":
        return _cstl.VecMapStrStr_rbegin(self)

    def rend(self) -> "std::vector< std::unordered_map< std::string,std::string > >::reverse_iterator":
        return _cstl.VecMapStrStr_rend(self)

    def clear(self) -> "void":
        return _cstl.VecMapStrStr_clear(self)

    def get_allocator(self) -> "std::vector< std::unordered_map< std::string,std::string > >::allocator_type":
        return _cstl.VecMapStrStr_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecMapStrStr_pop_back(self)

    def erase(self, *args) -> "std::vector< std::unordered_map< std::string,std::string > >::iterator":
        return _cstl.VecMapStrStr_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecMapStrStr_swiginit(self, _cstl.new_VecMapStrStr(*args))

    def push_back(self, x: "MapStrStr") -> "void":
        return _cstl.VecMapStrStr_push_back(self, x)

    def front(self) -> "std::vector< std::unordered_map< std::string,std::string > >::value_type const &":
        return _cstl.VecMapStrStr_front(self)

    def back(self) -> "std::vector< std::unordered_map< std::string,std::string > >::value_type const &":
        return _cstl.VecMapStrStr_back(self)

    def assign(self, n: "std::vector< std::unordered_map< std::string,std::string > >::size_type", x: "MapStrStr") -> "void":
        return _cstl.VecMapStrStr_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecMapStrStr_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecMapStrStr_insert(self, *args)

    def reserve(self, n: "std::vector< std::unordered_map< std::string,std::string > >::size_type") -> "void":
        return _cstl.VecMapStrStr_reserve(self, n)

    def capacity(self) -> "std::vector< std::unordered_map< std::string,std::string > >::size_type":
        return _cstl.VecMapStrStr_capacity(self)
    __swig_destroy__ = _cstl.delete_VecMapStrStr

# Register VecMapStrStr in _cstl:
_cstl.VecMapStrStr_swigregister(VecMapStrStr)

class VecMapStrFloat(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecMapStrFloat_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecMapStrFloat___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecMapStrFloat___bool__(self)

    def __len__(self) -> "std::vector< std::unordered_map< std::string,float > >::size_type":
        return _cstl.VecMapStrFloat___len__(self)

    def __getslice__(self, i: "std::vector< std::unordered_map< std::string,float > >::difference_type", j: "std::vector< std::unordered_map< std::string,float > >::difference_type") -> "std::vector< std::unordered_map< std::string,float,std::hash< std::string >,std::equal_to< std::string >,std::allocator< std::pair< std::string const,float > > >,std::allocator< std::unordered_map< std::string,float,std::hash< std::string >,std::equal_to< std::string >,std::allocator< std::pair< std::string const,float > > > > > *":
        return _cstl.VecMapStrFloat___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecMapStrFloat___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::unordered_map< std::string,float > >::difference_type", j: "std::vector< std::unordered_map< std::string,float > >::difference_type") -> "void":
        return _cstl.VecMapStrFloat___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecMapStrFloat___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::unordered_map< std::string,float > >::value_type const &":
        return _cstl.VecMapStrFloat___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecMapStrFloat___setitem__(self, *args)

    def pop(self) -> "std::vector< std::unordered_map< std::string,float > >::value_type":
        return _cstl.VecMapStrFloat_pop(self)

    def append(self, x: "MapStrFloat") -> "void":
        return _cstl.VecMapStrFloat_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecMapStrFloat_empty(self)

    def size(self) -> "std::vector< std::unordered_map< std::string,float > >::size_type":
        return _cstl.VecMapStrFloat_size(self)

    def swap(self, v: "VecMapStrFloat") -> "void":
        return _cstl.VecMapStrFloat_swap(self, v)

    def begin(self) -> "std::vector< std::unordered_map< std::string,float > >::iterator":
        return _cstl.VecMapStrFloat_begin(self)

    def end(self) -> "std::vector< std::unordered_map< std::string,float > >::iterator":
        return _cstl.VecMapStrFloat_end(self)

    def rbegin(self) -> "std::vector< std::unordered_map< std::string,float > >::reverse_iterator":
        return _cstl.VecMapStrFloat_rbegin(self)

    def rend(self) -> "std::vector< std::unordered_map< std::string,float > >::reverse_iterator":
        return _cstl.VecMapStrFloat_rend(self)

    def clear(self) -> "void":
        return _cstl.VecMapStrFloat_clear(self)

    def get_allocator(self) -> "std::vector< std::unordered_map< std::string,float > >::allocator_type":
        return _cstl.VecMapStrFloat_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecMapStrFloat_pop_back(self)

    def erase(self, *args) -> "std::vector< std::unordered_map< std::string,float > >::iterator":
        return _cstl.VecMapStrFloat_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecMapStrFloat_swiginit(self, _cstl.new_VecMapStrFloat(*args))

    def push_back(self, x: "MapStrFloat") -> "void":
        return _cstl.VecMapStrFloat_push_back(self, x)

    def front(self) -> "std::vector< std::unordered_map< std::string,float > >::value_type const &":
        return _cstl.VecMapStrFloat_front(self)

    def back(self) -> "std::vector< std::unordered_map< std::string,float > >::value_type const &":
        return _cstl.VecMapStrFloat_back(self)

    def assign(self, n: "std::vector< std::unordered_map< std::string,float > >::size_type", x: "MapStrFloat") -> "void":
        return _cstl.VecMapStrFloat_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecMapStrFloat_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecMapStrFloat_insert(self, *args)

    def reserve(self, n: "std::vector< std::unordered_map< std::string,float > >::size_type") -> "void":
        return _cstl.VecMapStrFloat_reserve(self, n)

    def capacity(self) -> "std::vector< std::unordered_map< std::string,float > >::size_type":
        return _cstl.VecMapStrFloat_capacity(self)
    __swig_destroy__ = _cstl.delete_VecMapStrFloat

# Register VecMapStrFloat in _cstl:
_cstl.VecMapStrFloat_swigregister(VecMapStrFloat)

class VecMapStrDouble(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecMapStrDouble_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecMapStrDouble___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecMapStrDouble___bool__(self)

    def __len__(self) -> "std::vector< std::unordered_map< std::string,double > >::size_type":
        return _cstl.VecMapStrDouble___len__(self)

    def __getslice__(self, i: "std::vector< std::unordered_map< std::string,double > >::difference_type", j: "std::vector< std::unordered_map< std::string,double > >::difference_type") -> "std::vector< std::unordered_map< std::string,double,std::hash< std::string >,std::equal_to< std::string >,std::allocator< std::pair< std::string const,double > > >,std::allocator< std::unordered_map< std::string,double,std::hash< std::string >,std::equal_to< std::string >,std::allocator< std::pair< std::string const,double > > > > > *":
        return _cstl.VecMapStrDouble___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecMapStrDouble___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::unordered_map< std::string,double > >::difference_type", j: "std::vector< std::unordered_map< std::string,double > >::difference_type") -> "void":
        return _cstl.VecMapStrDouble___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecMapStrDouble___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::unordered_map< std::string,double > >::value_type const &":
        return _cstl.VecMapStrDouble___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecMapStrDouble___setitem__(self, *args)

    def pop(self) -> "std::vector< std::unordered_map< std::string,double > >::value_type":
        return _cstl.VecMapStrDouble_pop(self)

    def append(self, x: "MapStrDouble") -> "void":
        return _cstl.VecMapStrDouble_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecMapStrDouble_empty(self)

    def size(self) -> "std::vector< std::unordered_map< std::string,double > >::size_type":
        return _cstl.VecMapStrDouble_size(self)

    def swap(self, v: "VecMapStrDouble") -> "void":
        return _cstl.VecMapStrDouble_swap(self, v)

    def begin(self) -> "std::vector< std::unordered_map< std::string,double > >::iterator":
        return _cstl.VecMapStrDouble_begin(self)

    def end(self) -> "std::vector< std::unordered_map< std::string,double > >::iterator":
        return _cstl.VecMapStrDouble_end(self)

    def rbegin(self) -> "std::vector< std::unordered_map< std::string,double > >::reverse_iterator":
        return _cstl.VecMapStrDouble_rbegin(self)

    def rend(self) -> "std::vector< std::unordered_map< std::string,double > >::reverse_iterator":
        return _cstl.VecMapStrDouble_rend(self)

    def clear(self) -> "void":
        return _cstl.VecMapStrDouble_clear(self)

    def get_allocator(self) -> "std::vector< std::unordered_map< std::string,double > >::allocator_type":
        return _cstl.VecMapStrDouble_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecMapStrDouble_pop_back(self)

    def erase(self, *args) -> "std::vector< std::unordered_map< std::string,double > >::iterator":
        return _cstl.VecMapStrDouble_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecMapStrDouble_swiginit(self, _cstl.new_VecMapStrDouble(*args))

    def push_back(self, x: "MapStrDouble") -> "void":
        return _cstl.VecMapStrDouble_push_back(self, x)

    def front(self) -> "std::vector< std::unordered_map< std::string,double > >::value_type const &":
        return _cstl.VecMapStrDouble_front(self)

    def back(self) -> "std::vector< std::unordered_map< std::string,double > >::value_type const &":
        return _cstl.VecMapStrDouble_back(self)

    def assign(self, n: "std::vector< std::unordered_map< std::string,double > >::size_type", x: "MapStrDouble") -> "void":
        return _cstl.VecMapStrDouble_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecMapStrDouble_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecMapStrDouble_insert(self, *args)

    def reserve(self, n: "std::vector< std::unordered_map< std::string,double > >::size_type") -> "void":
        return _cstl.VecMapStrDouble_reserve(self, n)

    def capacity(self) -> "std::vector< std::unordered_map< std::string,double > >::size_type":
        return _cstl.VecMapStrDouble_capacity(self)
    __swig_destroy__ = _cstl.delete_VecMapStrDouble

# Register VecMapStrDouble in _cstl:
_cstl.VecMapStrDouble_swigregister(VecMapStrDouble)

class VecMapStrBool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecMapStrBool_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecMapStrBool___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecMapStrBool___bool__(self)

    def __len__(self) -> "std::vector< std::unordered_map< std::string,bool > >::size_type":
        return _cstl.VecMapStrBool___len__(self)

    def __getslice__(self, i: "std::vector< std::unordered_map< std::string,bool > >::difference_type", j: "std::vector< std::unordered_map< std::string,bool > >::difference_type") -> "std::vector< std::unordered_map< std::string,bool,std::hash< std::string >,std::equal_to< std::string >,std::allocator< std::pair< std::string const,bool > > >,std::allocator< std::unordered_map< std::string,bool,std::hash< std::string >,std::equal_to< std::string >,std::allocator< std::pair< std::string const,bool > > > > > *":
        return _cstl.VecMapStrBool___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecMapStrBool___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::unordered_map< std::string,bool > >::difference_type", j: "std::vector< std::unordered_map< std::string,bool > >::difference_type") -> "void":
        return _cstl.VecMapStrBool___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecMapStrBool___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::unordered_map< std::string,bool > >::value_type const &":
        return _cstl.VecMapStrBool___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecMapStrBool___setitem__(self, *args)

    def pop(self) -> "std::vector< std::unordered_map< std::string,bool > >::value_type":
        return _cstl.VecMapStrBool_pop(self)

    def append(self, x: "MapStrBool") -> "void":
        return _cstl.VecMapStrBool_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecMapStrBool_empty(self)

    def size(self) -> "std::vector< std::unordered_map< std::string,bool > >::size_type":
        return _cstl.VecMapStrBool_size(self)

    def swap(self, v: "VecMapStrBool") -> "void":
        return _cstl.VecMapStrBool_swap(self, v)

    def begin(self) -> "std::vector< std::unordered_map< std::string,bool > >::iterator":
        return _cstl.VecMapStrBool_begin(self)

    def end(self) -> "std::vector< std::unordered_map< std::string,bool > >::iterator":
        return _cstl.VecMapStrBool_end(self)

    def rbegin(self) -> "std::vector< std::unordered_map< std::string,bool > >::reverse_iterator":
        return _cstl.VecMapStrBool_rbegin(self)

    def rend(self) -> "std::vector< std::unordered_map< std::string,bool > >::reverse_iterator":
        return _cstl.VecMapStrBool_rend(self)

    def clear(self) -> "void":
        return _cstl.VecMapStrBool_clear(self)

    def get_allocator(self) -> "std::vector< std::unordered_map< std::string,bool > >::allocator_type":
        return _cstl.VecMapStrBool_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecMapStrBool_pop_back(self)

    def erase(self, *args) -> "std::vector< std::unordered_map< std::string,bool > >::iterator":
        return _cstl.VecMapStrBool_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecMapStrBool_swiginit(self, _cstl.new_VecMapStrBool(*args))

    def push_back(self, x: "MapStrBool") -> "void":
        return _cstl.VecMapStrBool_push_back(self, x)

    def front(self) -> "std::vector< std::unordered_map< std::string,bool > >::value_type const &":
        return _cstl.VecMapStrBool_front(self)

    def back(self) -> "std::vector< std::unordered_map< std::string,bool > >::value_type const &":
        return _cstl.VecMapStrBool_back(self)

    def assign(self, n: "std::vector< std::unordered_map< std::string,bool > >::size_type", x: "MapStrBool") -> "void":
        return _cstl.VecMapStrBool_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecMapStrBool_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecMapStrBool_insert(self, *args)

    def reserve(self, n: "std::vector< std::unordered_map< std::string,bool > >::size_type") -> "void":
        return _cstl.VecMapStrBool_reserve(self, n)

    def capacity(self) -> "std::vector< std::unordered_map< std::string,bool > >::size_type":
        return _cstl.VecMapStrBool_capacity(self)
    __swig_destroy__ = _cstl.delete_VecMapStrBool

# Register VecMapStrBool in _cstl:
_cstl.VecMapStrBool_swigregister(VecMapStrBool)

class VecMapStrLong(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecMapStrLong_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecMapStrLong___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecMapStrLong___bool__(self)

    def __len__(self) -> "std::vector< std::unordered_map< std::string,std::int64_t > >::size_type":
        return _cstl.VecMapStrLong___len__(self)

    def __getslice__(self, i: "std::vector< std::unordered_map< std::string,std::int64_t > >::difference_type", j: "std::vector< std::unordered_map< std::string,std::int64_t > >::difference_type") -> "std::vector< std::unordered_map< std::string,std::int64_t,std::hash< std::string >,std::equal_to< std::string >,std::allocator< std::pair< std::string const,std::int64_t > > >,std::allocator< std::unordered_map< std::string,std::int64_t,std::hash< std::string >,std::equal_to< std::string >,std::allocator< std::pair< std::string const,std::int64_t > > > > > *":
        return _cstl.VecMapStrLong___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecMapStrLong___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::unordered_map< std::string,std::int64_t > >::difference_type", j: "std::vector< std::unordered_map< std::string,std::int64_t > >::difference_type") -> "void":
        return _cstl.VecMapStrLong___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecMapStrLong___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::unordered_map< std::string,std::int64_t > >::value_type const &":
        return _cstl.VecMapStrLong___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecMapStrLong___setitem__(self, *args)

    def pop(self) -> "std::vector< std::unordered_map< std::string,std::int64_t > >::value_type":
        return _cstl.VecMapStrLong_pop(self)

    def append(self, x: "MapStrLong") -> "void":
        return _cstl.VecMapStrLong_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecMapStrLong_empty(self)

    def size(self) -> "std::vector< std::unordered_map< std::string,std::int64_t > >::size_type":
        return _cstl.VecMapStrLong_size(self)

    def swap(self, v: "VecMapStrLong") -> "void":
        return _cstl.VecMapStrLong_swap(self, v)

    def begin(self) -> "std::vector< std::unordered_map< std::string,std::int64_t > >::iterator":
        return _cstl.VecMapStrLong_begin(self)

    def end(self) -> "std::vector< std::unordered_map< std::string,std::int64_t > >::iterator":
        return _cstl.VecMapStrLong_end(self)

    def rbegin(self) -> "std::vector< std::unordered_map< std::string,std::int64_t > >::reverse_iterator":
        return _cstl.VecMapStrLong_rbegin(self)

    def rend(self) -> "std::vector< std::unordered_map< std::string,std::int64_t > >::reverse_iterator":
        return _cstl.VecMapStrLong_rend(self)

    def clear(self) -> "void":
        return _cstl.VecMapStrLong_clear(self)

    def get_allocator(self) -> "std::vector< std::unordered_map< std::string,std::int64_t > >::allocator_type":
        return _cstl.VecMapStrLong_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecMapStrLong_pop_back(self)

    def erase(self, *args) -> "std::vector< std::unordered_map< std::string,std::int64_t > >::iterator":
        return _cstl.VecMapStrLong_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecMapStrLong_swiginit(self, _cstl.new_VecMapStrLong(*args))

    def push_back(self, x: "MapStrLong") -> "void":
        return _cstl.VecMapStrLong_push_back(self, x)

    def front(self) -> "std::vector< std::unordered_map< std::string,std::int64_t > >::value_type const &":
        return _cstl.VecMapStrLong_front(self)

    def back(self) -> "std::vector< std::unordered_map< std::string,std::int64_t > >::value_type const &":
        return _cstl.VecMapStrLong_back(self)

    def assign(self, n: "std::vector< std::unordered_map< std::string,std::int64_t > >::size_type", x: "MapStrLong") -> "void":
        return _cstl.VecMapStrLong_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecMapStrLong_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecMapStrLong_insert(self, *args)

    def reserve(self, n: "std::vector< std::unordered_map< std::string,std::int64_t > >::size_type") -> "void":
        return _cstl.VecMapStrLong_reserve(self, n)

    def capacity(self) -> "std::vector< std::unordered_map< std::string,std::int64_t > >::size_type":
        return _cstl.VecMapStrLong_capacity(self)
    __swig_destroy__ = _cstl.delete_VecMapStrLong

# Register VecMapStrLong in _cstl:
_cstl.VecMapStrLong_swigregister(VecMapStrLong)

class VecMapLongInt(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecMapLongInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecMapLongInt___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecMapLongInt___bool__(self)

    def __len__(self) -> "std::vector< std::unordered_map< std::int64_t,int > >::size_type":
        return _cstl.VecMapLongInt___len__(self)

    def __getslice__(self, i: "std::vector< std::unordered_map< std::int64_t,int > >::difference_type", j: "std::vector< std::unordered_map< std::int64_t,int > >::difference_type") -> "std::vector< std::unordered_map< std::int64_t,int,std::hash< std::int64_t >,std::equal_to< std::int64_t >,std::allocator< std::pair< std::int64_t const,int > > >,std::allocator< std::unordered_map< std::int64_t,int,std::hash< std::int64_t >,std::equal_to< std::int64_t >,std::allocator< std::pair< std::int64_t const,int > > > > > *":
        return _cstl.VecMapLongInt___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecMapLongInt___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::unordered_map< std::int64_t,int > >::difference_type", j: "std::vector< std::unordered_map< std::int64_t,int > >::difference_type") -> "void":
        return _cstl.VecMapLongInt___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecMapLongInt___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::unordered_map< std::int64_t,int > >::value_type const &":
        return _cstl.VecMapLongInt___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecMapLongInt___setitem__(self, *args)

    def pop(self) -> "std::vector< std::unordered_map< std::int64_t,int > >::value_type":
        return _cstl.VecMapLongInt_pop(self)

    def append(self, x: "MapLongInt") -> "void":
        return _cstl.VecMapLongInt_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecMapLongInt_empty(self)

    def size(self) -> "std::vector< std::unordered_map< std::int64_t,int > >::size_type":
        return _cstl.VecMapLongInt_size(self)

    def swap(self, v: "VecMapLongInt") -> "void":
        return _cstl.VecMapLongInt_swap(self, v)

    def begin(self) -> "std::vector< std::unordered_map< std::int64_t,int > >::iterator":
        return _cstl.VecMapLongInt_begin(self)

    def end(self) -> "std::vector< std::unordered_map< std::int64_t,int > >::iterator":
        return _cstl.VecMapLongInt_end(self)

    def rbegin(self) -> "std::vector< std::unordered_map< std::int64_t,int > >::reverse_iterator":
        return _cstl.VecMapLongInt_rbegin(self)

    def rend(self) -> "std::vector< std::unordered_map< std::int64_t,int > >::reverse_iterator":
        return _cstl.VecMapLongInt_rend(self)

    def clear(self) -> "void":
        return _cstl.VecMapLongInt_clear(self)

    def get_allocator(self) -> "std::vector< std::unordered_map< std::int64_t,int > >::allocator_type":
        return _cstl.VecMapLongInt_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecMapLongInt_pop_back(self)

    def erase(self, *args) -> "std::vector< std::unordered_map< std::int64_t,int > >::iterator":
        return _cstl.VecMapLongInt_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecMapLongInt_swiginit(self, _cstl.new_VecMapLongInt(*args))

    def push_back(self, x: "MapLongInt") -> "void":
        return _cstl.VecMapLongInt_push_back(self, x)

    def front(self) -> "std::vector< std::unordered_map< std::int64_t,int > >::value_type const &":
        return _cstl.VecMapLongInt_front(self)

    def back(self) -> "std::vector< std::unordered_map< std::int64_t,int > >::value_type const &":
        return _cstl.VecMapLongInt_back(self)

    def assign(self, n: "std::vector< std::unordered_map< std::int64_t,int > >::size_type", x: "MapLongInt") -> "void":
        return _cstl.VecMapLongInt_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecMapLongInt_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecMapLongInt_insert(self, *args)

    def reserve(self, n: "std::vector< std::unordered_map< std::int64_t,int > >::size_type") -> "void":
        return _cstl.VecMapLongInt_reserve(self, n)

    def capacity(self) -> "std::vector< std::unordered_map< std::int64_t,int > >::size_type":
        return _cstl.VecMapLongInt_capacity(self)
    __swig_destroy__ = _cstl.delete_VecMapLongInt

# Register VecMapLongInt in _cstl:
_cstl.VecMapLongInt_swigregister(VecMapLongInt)

class VecMapLongStr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecMapLongStr_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecMapLongStr___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecMapLongStr___bool__(self)

    def __len__(self) -> "std::vector< std::unordered_map< std::int64_t,std::string > >::size_type":
        return _cstl.VecMapLongStr___len__(self)

    def __getslice__(self, i: "std::vector< std::unordered_map< std::int64_t,std::string > >::difference_type", j: "std::vector< std::unordered_map< std::int64_t,std::string > >::difference_type") -> "std::vector< std::unordered_map< std::int64_t,std::string,std::hash< std::int64_t >,std::equal_to< std::int64_t >,std::allocator< std::pair< std::int64_t const,std::string > > >,std::allocator< std::unordered_map< std::int64_t,std::string,std::hash< std::int64_t >,std::equal_to< std::int64_t >,std::allocator< std::pair< std::int64_t const,std::string > > > > > *":
        return _cstl.VecMapLongStr___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecMapLongStr___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::unordered_map< std::int64_t,std::string > >::difference_type", j: "std::vector< std::unordered_map< std::int64_t,std::string > >::difference_type") -> "void":
        return _cstl.VecMapLongStr___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecMapLongStr___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::unordered_map< std::int64_t,std::string > >::value_type const &":
        return _cstl.VecMapLongStr___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecMapLongStr___setitem__(self, *args)

    def pop(self) -> "std::vector< std::unordered_map< std::int64_t,std::string > >::value_type":
        return _cstl.VecMapLongStr_pop(self)

    def append(self, x: "MapLongStr") -> "void":
        return _cstl.VecMapLongStr_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecMapLongStr_empty(self)

    def size(self) -> "std::vector< std::unordered_map< std::int64_t,std::string > >::size_type":
        return _cstl.VecMapLongStr_size(self)

    def swap(self, v: "VecMapLongStr") -> "void":
        return _cstl.VecMapLongStr_swap(self, v)

    def begin(self) -> "std::vector< std::unordered_map< std::int64_t,std::string > >::iterator":
        return _cstl.VecMapLongStr_begin(self)

    def end(self) -> "std::vector< std::unordered_map< std::int64_t,std::string > >::iterator":
        return _cstl.VecMapLongStr_end(self)

    def rbegin(self) -> "std::vector< std::unordered_map< std::int64_t,std::string > >::reverse_iterator":
        return _cstl.VecMapLongStr_rbegin(self)

    def rend(self) -> "std::vector< std::unordered_map< std::int64_t,std::string > >::reverse_iterator":
        return _cstl.VecMapLongStr_rend(self)

    def clear(self) -> "void":
        return _cstl.VecMapLongStr_clear(self)

    def get_allocator(self) -> "std::vector< std::unordered_map< std::int64_t,std::string > >::allocator_type":
        return _cstl.VecMapLongStr_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecMapLongStr_pop_back(self)

    def erase(self, *args) -> "std::vector< std::unordered_map< std::int64_t,std::string > >::iterator":
        return _cstl.VecMapLongStr_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecMapLongStr_swiginit(self, _cstl.new_VecMapLongStr(*args))

    def push_back(self, x: "MapLongStr") -> "void":
        return _cstl.VecMapLongStr_push_back(self, x)

    def front(self) -> "std::vector< std::unordered_map< std::int64_t,std::string > >::value_type const &":
        return _cstl.VecMapLongStr_front(self)

    def back(self) -> "std::vector< std::unordered_map< std::int64_t,std::string > >::value_type const &":
        return _cstl.VecMapLongStr_back(self)

    def assign(self, n: "std::vector< std::unordered_map< std::int64_t,std::string > >::size_type", x: "MapLongStr") -> "void":
        return _cstl.VecMapLongStr_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecMapLongStr_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecMapLongStr_insert(self, *args)

    def reserve(self, n: "std::vector< std::unordered_map< std::int64_t,std::string > >::size_type") -> "void":
        return _cstl.VecMapLongStr_reserve(self, n)

    def capacity(self) -> "std::vector< std::unordered_map< std::int64_t,std::string > >::size_type":
        return _cstl.VecMapLongStr_capacity(self)
    __swig_destroy__ = _cstl.delete_VecMapLongStr

# Register VecMapLongStr in _cstl:
_cstl.VecMapLongStr_swigregister(VecMapLongStr)

class VecMapLongFloat(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecMapLongFloat_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecMapLongFloat___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecMapLongFloat___bool__(self)

    def __len__(self) -> "std::vector< std::unordered_map< std::int64_t,float > >::size_type":
        return _cstl.VecMapLongFloat___len__(self)

    def __getslice__(self, i: "std::vector< std::unordered_map< std::int64_t,float > >::difference_type", j: "std::vector< std::unordered_map< std::int64_t,float > >::difference_type") -> "std::vector< std::unordered_map< std::int64_t,float,std::hash< std::int64_t >,std::equal_to< std::int64_t >,std::allocator< std::pair< std::int64_t const,float > > >,std::allocator< std::unordered_map< std::int64_t,float,std::hash< std::int64_t >,std::equal_to< std::int64_t >,std::allocator< std::pair< std::int64_t const,float > > > > > *":
        return _cstl.VecMapLongFloat___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecMapLongFloat___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::unordered_map< std::int64_t,float > >::difference_type", j: "std::vector< std::unordered_map< std::int64_t,float > >::difference_type") -> "void":
        return _cstl.VecMapLongFloat___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecMapLongFloat___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::unordered_map< std::int64_t,float > >::value_type const &":
        return _cstl.VecMapLongFloat___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecMapLongFloat___setitem__(self, *args)

    def pop(self) -> "std::vector< std::unordered_map< std::int64_t,float > >::value_type":
        return _cstl.VecMapLongFloat_pop(self)

    def append(self, x: "MapLongFloat") -> "void":
        return _cstl.VecMapLongFloat_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecMapLongFloat_empty(self)

    def size(self) -> "std::vector< std::unordered_map< std::int64_t,float > >::size_type":
        return _cstl.VecMapLongFloat_size(self)

    def swap(self, v: "VecMapLongFloat") -> "void":
        return _cstl.VecMapLongFloat_swap(self, v)

    def begin(self) -> "std::vector< std::unordered_map< std::int64_t,float > >::iterator":
        return _cstl.VecMapLongFloat_begin(self)

    def end(self) -> "std::vector< std::unordered_map< std::int64_t,float > >::iterator":
        return _cstl.VecMapLongFloat_end(self)

    def rbegin(self) -> "std::vector< std::unordered_map< std::int64_t,float > >::reverse_iterator":
        return _cstl.VecMapLongFloat_rbegin(self)

    def rend(self) -> "std::vector< std::unordered_map< std::int64_t,float > >::reverse_iterator":
        return _cstl.VecMapLongFloat_rend(self)

    def clear(self) -> "void":
        return _cstl.VecMapLongFloat_clear(self)

    def get_allocator(self) -> "std::vector< std::unordered_map< std::int64_t,float > >::allocator_type":
        return _cstl.VecMapLongFloat_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecMapLongFloat_pop_back(self)

    def erase(self, *args) -> "std::vector< std::unordered_map< std::int64_t,float > >::iterator":
        return _cstl.VecMapLongFloat_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecMapLongFloat_swiginit(self, _cstl.new_VecMapLongFloat(*args))

    def push_back(self, x: "MapLongFloat") -> "void":
        return _cstl.VecMapLongFloat_push_back(self, x)

    def front(self) -> "std::vector< std::unordered_map< std::int64_t,float > >::value_type const &":
        return _cstl.VecMapLongFloat_front(self)

    def back(self) -> "std::vector< std::unordered_map< std::int64_t,float > >::value_type const &":
        return _cstl.VecMapLongFloat_back(self)

    def assign(self, n: "std::vector< std::unordered_map< std::int64_t,float > >::size_type", x: "MapLongFloat") -> "void":
        return _cstl.VecMapLongFloat_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecMapLongFloat_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecMapLongFloat_insert(self, *args)

    def reserve(self, n: "std::vector< std::unordered_map< std::int64_t,float > >::size_type") -> "void":
        return _cstl.VecMapLongFloat_reserve(self, n)

    def capacity(self) -> "std::vector< std::unordered_map< std::int64_t,float > >::size_type":
        return _cstl.VecMapLongFloat_capacity(self)
    __swig_destroy__ = _cstl.delete_VecMapLongFloat

# Register VecMapLongFloat in _cstl:
_cstl.VecMapLongFloat_swigregister(VecMapLongFloat)

class VecMapLongDouble(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecMapLongDouble_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecMapLongDouble___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecMapLongDouble___bool__(self)

    def __len__(self) -> "std::vector< std::unordered_map< std::int64_t,double > >::size_type":
        return _cstl.VecMapLongDouble___len__(self)

    def __getslice__(self, i: "std::vector< std::unordered_map< std::int64_t,double > >::difference_type", j: "std::vector< std::unordered_map< std::int64_t,double > >::difference_type") -> "std::vector< std::unordered_map< std::int64_t,double,std::hash< std::int64_t >,std::equal_to< std::int64_t >,std::allocator< std::pair< std::int64_t const,double > > >,std::allocator< std::unordered_map< std::int64_t,double,std::hash< std::int64_t >,std::equal_to< std::int64_t >,std::allocator< std::pair< std::int64_t const,double > > > > > *":
        return _cstl.VecMapLongDouble___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecMapLongDouble___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::unordered_map< std::int64_t,double > >::difference_type", j: "std::vector< std::unordered_map< std::int64_t,double > >::difference_type") -> "void":
        return _cstl.VecMapLongDouble___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecMapLongDouble___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::unordered_map< std::int64_t,double > >::value_type const &":
        return _cstl.VecMapLongDouble___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecMapLongDouble___setitem__(self, *args)

    def pop(self) -> "std::vector< std::unordered_map< std::int64_t,double > >::value_type":
        return _cstl.VecMapLongDouble_pop(self)

    def append(self, x: "MapLongDouble") -> "void":
        return _cstl.VecMapLongDouble_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecMapLongDouble_empty(self)

    def size(self) -> "std::vector< std::unordered_map< std::int64_t,double > >::size_type":
        return _cstl.VecMapLongDouble_size(self)

    def swap(self, v: "VecMapLongDouble") -> "void":
        return _cstl.VecMapLongDouble_swap(self, v)

    def begin(self) -> "std::vector< std::unordered_map< std::int64_t,double > >::iterator":
        return _cstl.VecMapLongDouble_begin(self)

    def end(self) -> "std::vector< std::unordered_map< std::int64_t,double > >::iterator":
        return _cstl.VecMapLongDouble_end(self)

    def rbegin(self) -> "std::vector< std::unordered_map< std::int64_t,double > >::reverse_iterator":
        return _cstl.VecMapLongDouble_rbegin(self)

    def rend(self) -> "std::vector< std::unordered_map< std::int64_t,double > >::reverse_iterator":
        return _cstl.VecMapLongDouble_rend(self)

    def clear(self) -> "void":
        return _cstl.VecMapLongDouble_clear(self)

    def get_allocator(self) -> "std::vector< std::unordered_map< std::int64_t,double > >::allocator_type":
        return _cstl.VecMapLongDouble_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecMapLongDouble_pop_back(self)

    def erase(self, *args) -> "std::vector< std::unordered_map< std::int64_t,double > >::iterator":
        return _cstl.VecMapLongDouble_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecMapLongDouble_swiginit(self, _cstl.new_VecMapLongDouble(*args))

    def push_back(self, x: "MapLongDouble") -> "void":
        return _cstl.VecMapLongDouble_push_back(self, x)

    def front(self) -> "std::vector< std::unordered_map< std::int64_t,double > >::value_type const &":
        return _cstl.VecMapLongDouble_front(self)

    def back(self) -> "std::vector< std::unordered_map< std::int64_t,double > >::value_type const &":
        return _cstl.VecMapLongDouble_back(self)

    def assign(self, n: "std::vector< std::unordered_map< std::int64_t,double > >::size_type", x: "MapLongDouble") -> "void":
        return _cstl.VecMapLongDouble_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecMapLongDouble_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecMapLongDouble_insert(self, *args)

    def reserve(self, n: "std::vector< std::unordered_map< std::int64_t,double > >::size_type") -> "void":
        return _cstl.VecMapLongDouble_reserve(self, n)

    def capacity(self) -> "std::vector< std::unordered_map< std::int64_t,double > >::size_type":
        return _cstl.VecMapLongDouble_capacity(self)
    __swig_destroy__ = _cstl.delete_VecMapLongDouble

# Register VecMapLongDouble in _cstl:
_cstl.VecMapLongDouble_swigregister(VecMapLongDouble)

class VecMapLongBool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecMapLongBool_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecMapLongBool___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecMapLongBool___bool__(self)

    def __len__(self) -> "std::vector< std::unordered_map< std::int64_t,bool > >::size_type":
        return _cstl.VecMapLongBool___len__(self)

    def __getslice__(self, i: "std::vector< std::unordered_map< std::int64_t,bool > >::difference_type", j: "std::vector< std::unordered_map< std::int64_t,bool > >::difference_type") -> "std::vector< std::unordered_map< std::int64_t,bool,std::hash< std::int64_t >,std::equal_to< std::int64_t >,std::allocator< std::pair< std::int64_t const,bool > > >,std::allocator< std::unordered_map< std::int64_t,bool,std::hash< std::int64_t >,std::equal_to< std::int64_t >,std::allocator< std::pair< std::int64_t const,bool > > > > > *":
        return _cstl.VecMapLongBool___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecMapLongBool___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::unordered_map< std::int64_t,bool > >::difference_type", j: "std::vector< std::unordered_map< std::int64_t,bool > >::difference_type") -> "void":
        return _cstl.VecMapLongBool___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecMapLongBool___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::unordered_map< std::int64_t,bool > >::value_type const &":
        return _cstl.VecMapLongBool___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecMapLongBool___setitem__(self, *args)

    def pop(self) -> "std::vector< std::unordered_map< std::int64_t,bool > >::value_type":
        return _cstl.VecMapLongBool_pop(self)

    def append(self, x: "MapLongBool") -> "void":
        return _cstl.VecMapLongBool_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecMapLongBool_empty(self)

    def size(self) -> "std::vector< std::unordered_map< std::int64_t,bool > >::size_type":
        return _cstl.VecMapLongBool_size(self)

    def swap(self, v: "VecMapLongBool") -> "void":
        return _cstl.VecMapLongBool_swap(self, v)

    def begin(self) -> "std::vector< std::unordered_map< std::int64_t,bool > >::iterator":
        return _cstl.VecMapLongBool_begin(self)

    def end(self) -> "std::vector< std::unordered_map< std::int64_t,bool > >::iterator":
        return _cstl.VecMapLongBool_end(self)

    def rbegin(self) -> "std::vector< std::unordered_map< std::int64_t,bool > >::reverse_iterator":
        return _cstl.VecMapLongBool_rbegin(self)

    def rend(self) -> "std::vector< std::unordered_map< std::int64_t,bool > >::reverse_iterator":
        return _cstl.VecMapLongBool_rend(self)

    def clear(self) -> "void":
        return _cstl.VecMapLongBool_clear(self)

    def get_allocator(self) -> "std::vector< std::unordered_map< std::int64_t,bool > >::allocator_type":
        return _cstl.VecMapLongBool_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecMapLongBool_pop_back(self)

    def erase(self, *args) -> "std::vector< std::unordered_map< std::int64_t,bool > >::iterator":
        return _cstl.VecMapLongBool_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecMapLongBool_swiginit(self, _cstl.new_VecMapLongBool(*args))

    def push_back(self, x: "MapLongBool") -> "void":
        return _cstl.VecMapLongBool_push_back(self, x)

    def front(self) -> "std::vector< std::unordered_map< std::int64_t,bool > >::value_type const &":
        return _cstl.VecMapLongBool_front(self)

    def back(self) -> "std::vector< std::unordered_map< std::int64_t,bool > >::value_type const &":
        return _cstl.VecMapLongBool_back(self)

    def assign(self, n: "std::vector< std::unordered_map< std::int64_t,bool > >::size_type", x: "MapLongBool") -> "void":
        return _cstl.VecMapLongBool_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecMapLongBool_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecMapLongBool_insert(self, *args)

    def reserve(self, n: "std::vector< std::unordered_map< std::int64_t,bool > >::size_type") -> "void":
        return _cstl.VecMapLongBool_reserve(self, n)

    def capacity(self) -> "std::vector< std::unordered_map< std::int64_t,bool > >::size_type":
        return _cstl.VecMapLongBool_capacity(self)
    __swig_destroy__ = _cstl.delete_VecMapLongBool

# Register VecMapLongBool in _cstl:
_cstl.VecMapLongBool_swigregister(VecMapLongBool)

class VecMapLongLong(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.VecMapLongLong_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.VecMapLongLong___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.VecMapLongLong___bool__(self)

    def __len__(self) -> "std::vector< std::unordered_map< std::int64_t,std::int64_t > >::size_type":
        return _cstl.VecMapLongLong___len__(self)

    def __getslice__(self, i: "std::vector< std::unordered_map< std::int64_t,std::int64_t > >::difference_type", j: "std::vector< std::unordered_map< std::int64_t,std::int64_t > >::difference_type") -> "std::vector< std::unordered_map< std::int64_t,std::int64_t,std::hash< std::int64_t >,std::equal_to< std::int64_t >,std::allocator< std::pair< std::int64_t const,std::int64_t > > >,std::allocator< std::unordered_map< std::int64_t,std::int64_t,std::hash< std::int64_t >,std::equal_to< std::int64_t >,std::allocator< std::pair< std::int64_t const,std::int64_t > > > > > *":
        return _cstl.VecMapLongLong___getslice__(self, i, j)

    def __setslice__(self, *args) -> "void":
        return _cstl.VecMapLongLong___setslice__(self, *args)

    def __delslice__(self, i: "std::vector< std::unordered_map< std::int64_t,std::int64_t > >::difference_type", j: "std::vector< std::unordered_map< std::int64_t,std::int64_t > >::difference_type") -> "void":
        return _cstl.VecMapLongLong___delslice__(self, i, j)

    def __delitem__(self, *args) -> "void":
        return _cstl.VecMapLongLong___delitem__(self, *args)

    def __getitem__(self, *args) -> "std::vector< std::unordered_map< std::int64_t,std::int64_t > >::value_type const &":
        return _cstl.VecMapLongLong___getitem__(self, *args)

    def __setitem__(self, *args) -> "void":
        return _cstl.VecMapLongLong___setitem__(self, *args)

    def pop(self) -> "std::vector< std::unordered_map< std::int64_t,std::int64_t > >::value_type":
        return _cstl.VecMapLongLong_pop(self)

    def append(self, x: "MapLongLong") -> "void":
        return _cstl.VecMapLongLong_append(self, x)

    def empty(self) -> "bool":
        return _cstl.VecMapLongLong_empty(self)

    def size(self) -> "std::vector< std::unordered_map< std::int64_t,std::int64_t > >::size_type":
        return _cstl.VecMapLongLong_size(self)

    def swap(self, v: "VecMapLongLong") -> "void":
        return _cstl.VecMapLongLong_swap(self, v)

    def begin(self) -> "std::vector< std::unordered_map< std::int64_t,std::int64_t > >::iterator":
        return _cstl.VecMapLongLong_begin(self)

    def end(self) -> "std::vector< std::unordered_map< std::int64_t,std::int64_t > >::iterator":
        return _cstl.VecMapLongLong_end(self)

    def rbegin(self) -> "std::vector< std::unordered_map< std::int64_t,std::int64_t > >::reverse_iterator":
        return _cstl.VecMapLongLong_rbegin(self)

    def rend(self) -> "std::vector< std::unordered_map< std::int64_t,std::int64_t > >::reverse_iterator":
        return _cstl.VecMapLongLong_rend(self)

    def clear(self) -> "void":
        return _cstl.VecMapLongLong_clear(self)

    def get_allocator(self) -> "std::vector< std::unordered_map< std::int64_t,std::int64_t > >::allocator_type":
        return _cstl.VecMapLongLong_get_allocator(self)

    def pop_back(self) -> "void":
        return _cstl.VecMapLongLong_pop_back(self)

    def erase(self, *args) -> "std::vector< std::unordered_map< std::int64_t,std::int64_t > >::iterator":
        return _cstl.VecMapLongLong_erase(self, *args)

    def __init__(self, *args):
        _cstl.VecMapLongLong_swiginit(self, _cstl.new_VecMapLongLong(*args))

    def push_back(self, x: "MapLongLong") -> "void":
        return _cstl.VecMapLongLong_push_back(self, x)

    def front(self) -> "std::vector< std::unordered_map< std::int64_t,std::int64_t > >::value_type const &":
        return _cstl.VecMapLongLong_front(self)

    def back(self) -> "std::vector< std::unordered_map< std::int64_t,std::int64_t > >::value_type const &":
        return _cstl.VecMapLongLong_back(self)

    def assign(self, n: "std::vector< std::unordered_map< std::int64_t,std::int64_t > >::size_type", x: "MapLongLong") -> "void":
        return _cstl.VecMapLongLong_assign(self, n, x)

    def resize(self, *args) -> "void":
        return _cstl.VecMapLongLong_resize(self, *args)

    def insert(self, *args) -> "void":
        return _cstl.VecMapLongLong_insert(self, *args)

    def reserve(self, n: "std::vector< std::unordered_map< std::int64_t,std::int64_t > >::size_type") -> "void":
        return _cstl.VecMapLongLong_reserve(self, n)

    def capacity(self) -> "std::vector< std::unordered_map< std::int64_t,std::int64_t > >::size_type":
        return _cstl.VecMapLongLong_capacity(self)
    __swig_destroy__ = _cstl.delete_VecMapLongLong

# Register VecMapLongLong in _cstl:
_cstl.VecMapLongLong_swigregister(VecMapLongLong)

class MapIntVecInt(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntVecInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntVecInt___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntVecInt___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::vector< int > >::size_type":
        return _cstl.MapIntVecInt___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::vector< int > >::key_type const &") -> "std::unordered_map< int,std::vector< int > >::mapped_type const &":
        return _cstl.MapIntVecInt___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::vector< int > >::key_type const &") -> "void":
        return _cstl.MapIntVecInt___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::vector< int > >::key_type const &") -> "bool":
        return _cstl.MapIntVecInt_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntVecInt_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntVecInt_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntVecInt_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::vector< int > >::key_type const &") -> "bool":
        return _cstl.MapIntVecInt___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntVecInt_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntVecInt_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntVecInt___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntVecInt_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntVecInt_swiginit(self, _cstl.new_MapIntVecInt(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntVecInt_empty(self)

    def size(self) -> "std::unordered_map< int,std::vector< int > >::size_type":
        return _cstl.MapIntVecInt_size(self)

    def swap(self, v: "MapIntVecInt") -> "void":
        return _cstl.MapIntVecInt_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::vector< int > >::iterator":
        return _cstl.MapIntVecInt_begin(self)

    def end(self) -> "std::unordered_map< int,std::vector< int > >::iterator":
        return _cstl.MapIntVecInt_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntVecInt_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::vector< int > >::allocator_type":
        return _cstl.MapIntVecInt_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::vector< int > >::key_type const &") -> "std::unordered_map< int,std::vector< int > >::size_type":
        return _cstl.MapIntVecInt_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntVecInt_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::vector< int > >::key_type const &") -> "std::unordered_map< int,std::vector< int > >::iterator":
        return _cstl.MapIntVecInt_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntVecInt

# Register MapIntVecInt in _cstl:
_cstl.MapIntVecInt_swigregister(MapIntVecInt)

class MapIntVecStr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntVecStr_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntVecStr___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntVecStr___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::vector< std::string > >::size_type":
        return _cstl.MapIntVecStr___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::vector< std::string > >::key_type const &") -> "std::unordered_map< int,std::vector< std::string > >::mapped_type const &":
        return _cstl.MapIntVecStr___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::vector< std::string > >::key_type const &") -> "void":
        return _cstl.MapIntVecStr___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::vector< std::string > >::key_type const &") -> "bool":
        return _cstl.MapIntVecStr_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntVecStr_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntVecStr_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntVecStr_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::vector< std::string > >::key_type const &") -> "bool":
        return _cstl.MapIntVecStr___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntVecStr_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntVecStr_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntVecStr___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntVecStr_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntVecStr_swiginit(self, _cstl.new_MapIntVecStr(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntVecStr_empty(self)

    def size(self) -> "std::unordered_map< int,std::vector< std::string > >::size_type":
        return _cstl.MapIntVecStr_size(self)

    def swap(self, v: "MapIntVecStr") -> "void":
        return _cstl.MapIntVecStr_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::vector< std::string > >::iterator":
        return _cstl.MapIntVecStr_begin(self)

    def end(self) -> "std::unordered_map< int,std::vector< std::string > >::iterator":
        return _cstl.MapIntVecStr_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntVecStr_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::vector< std::string > >::allocator_type":
        return _cstl.MapIntVecStr_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::vector< std::string > >::key_type const &") -> "std::unordered_map< int,std::vector< std::string > >::size_type":
        return _cstl.MapIntVecStr_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntVecStr_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::vector< std::string > >::key_type const &") -> "std::unordered_map< int,std::vector< std::string > >::iterator":
        return _cstl.MapIntVecStr_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntVecStr

# Register MapIntVecStr in _cstl:
_cstl.MapIntVecStr_swigregister(MapIntVecStr)

class MapIntVecFloat(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntVecFloat_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntVecFloat___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntVecFloat___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::vector< float > >::size_type":
        return _cstl.MapIntVecFloat___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::vector< float > >::key_type const &") -> "std::unordered_map< int,std::vector< float > >::mapped_type const &":
        return _cstl.MapIntVecFloat___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::vector< float > >::key_type const &") -> "void":
        return _cstl.MapIntVecFloat___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::vector< float > >::key_type const &") -> "bool":
        return _cstl.MapIntVecFloat_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntVecFloat_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntVecFloat_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntVecFloat_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::vector< float > >::key_type const &") -> "bool":
        return _cstl.MapIntVecFloat___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntVecFloat_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntVecFloat_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntVecFloat___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntVecFloat_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntVecFloat_swiginit(self, _cstl.new_MapIntVecFloat(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntVecFloat_empty(self)

    def size(self) -> "std::unordered_map< int,std::vector< float > >::size_type":
        return _cstl.MapIntVecFloat_size(self)

    def swap(self, v: "MapIntVecFloat") -> "void":
        return _cstl.MapIntVecFloat_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::vector< float > >::iterator":
        return _cstl.MapIntVecFloat_begin(self)

    def end(self) -> "std::unordered_map< int,std::vector< float > >::iterator":
        return _cstl.MapIntVecFloat_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntVecFloat_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::vector< float > >::allocator_type":
        return _cstl.MapIntVecFloat_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::vector< float > >::key_type const &") -> "std::unordered_map< int,std::vector< float > >::size_type":
        return _cstl.MapIntVecFloat_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntVecFloat_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::vector< float > >::key_type const &") -> "std::unordered_map< int,std::vector< float > >::iterator":
        return _cstl.MapIntVecFloat_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntVecFloat

# Register MapIntVecFloat in _cstl:
_cstl.MapIntVecFloat_swigregister(MapIntVecFloat)

class MapIntVecDouble(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntVecDouble_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntVecDouble___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntVecDouble___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::vector< double > >::size_type":
        return _cstl.MapIntVecDouble___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::vector< double > >::key_type const &") -> "std::unordered_map< int,std::vector< double > >::mapped_type const &":
        return _cstl.MapIntVecDouble___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::vector< double > >::key_type const &") -> "void":
        return _cstl.MapIntVecDouble___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::vector< double > >::key_type const &") -> "bool":
        return _cstl.MapIntVecDouble_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntVecDouble_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntVecDouble_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntVecDouble_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::vector< double > >::key_type const &") -> "bool":
        return _cstl.MapIntVecDouble___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntVecDouble_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntVecDouble_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntVecDouble___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntVecDouble_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntVecDouble_swiginit(self, _cstl.new_MapIntVecDouble(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntVecDouble_empty(self)

    def size(self) -> "std::unordered_map< int,std::vector< double > >::size_type":
        return _cstl.MapIntVecDouble_size(self)

    def swap(self, v: "MapIntVecDouble") -> "void":
        return _cstl.MapIntVecDouble_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::vector< double > >::iterator":
        return _cstl.MapIntVecDouble_begin(self)

    def end(self) -> "std::unordered_map< int,std::vector< double > >::iterator":
        return _cstl.MapIntVecDouble_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntVecDouble_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::vector< double > >::allocator_type":
        return _cstl.MapIntVecDouble_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::vector< double > >::key_type const &") -> "std::unordered_map< int,std::vector< double > >::size_type":
        return _cstl.MapIntVecDouble_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntVecDouble_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::vector< double > >::key_type const &") -> "std::unordered_map< int,std::vector< double > >::iterator":
        return _cstl.MapIntVecDouble_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntVecDouble

# Register MapIntVecDouble in _cstl:
_cstl.MapIntVecDouble_swigregister(MapIntVecDouble)

class MapIntVecBool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntVecBool_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntVecBool___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntVecBool___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::vector< bool > >::size_type":
        return _cstl.MapIntVecBool___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::vector< bool > >::key_type const &") -> "std::unordered_map< int,std::vector< bool > >::mapped_type const &":
        return _cstl.MapIntVecBool___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::vector< bool > >::key_type const &") -> "void":
        return _cstl.MapIntVecBool___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::vector< bool > >::key_type const &") -> "bool":
        return _cstl.MapIntVecBool_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntVecBool_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntVecBool_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntVecBool_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::vector< bool > >::key_type const &") -> "bool":
        return _cstl.MapIntVecBool___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntVecBool_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntVecBool_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntVecBool___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntVecBool_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntVecBool_swiginit(self, _cstl.new_MapIntVecBool(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntVecBool_empty(self)

    def size(self) -> "std::unordered_map< int,std::vector< bool > >::size_type":
        return _cstl.MapIntVecBool_size(self)

    def swap(self, v: "MapIntVecBool") -> "void":
        return _cstl.MapIntVecBool_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::vector< bool > >::iterator":
        return _cstl.MapIntVecBool_begin(self)

    def end(self) -> "std::unordered_map< int,std::vector< bool > >::iterator":
        return _cstl.MapIntVecBool_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntVecBool_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::vector< bool > >::allocator_type":
        return _cstl.MapIntVecBool_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::vector< bool > >::key_type const &") -> "std::unordered_map< int,std::vector< bool > >::size_type":
        return _cstl.MapIntVecBool_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntVecBool_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::vector< bool > >::key_type const &") -> "std::unordered_map< int,std::vector< bool > >::iterator":
        return _cstl.MapIntVecBool_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntVecBool

# Register MapIntVecBool in _cstl:
_cstl.MapIntVecBool_swigregister(MapIntVecBool)

class MapIntVecLong(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntVecLong_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntVecLong___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntVecLong___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::vector< std::int64_t > >::size_type":
        return _cstl.MapIntVecLong___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::vector< std::int64_t > >::key_type const &") -> "std::unordered_map< int,std::vector< std::int64_t > >::mapped_type const &":
        return _cstl.MapIntVecLong___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::vector< std::int64_t > >::key_type const &") -> "void":
        return _cstl.MapIntVecLong___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::vector< std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapIntVecLong_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntVecLong_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntVecLong_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntVecLong_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::vector< std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapIntVecLong___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntVecLong_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntVecLong_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntVecLong___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntVecLong_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntVecLong_swiginit(self, _cstl.new_MapIntVecLong(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntVecLong_empty(self)

    def size(self) -> "std::unordered_map< int,std::vector< std::int64_t > >::size_type":
        return _cstl.MapIntVecLong_size(self)

    def swap(self, v: "MapIntVecLong") -> "void":
        return _cstl.MapIntVecLong_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::vector< std::int64_t > >::iterator":
        return _cstl.MapIntVecLong_begin(self)

    def end(self) -> "std::unordered_map< int,std::vector< std::int64_t > >::iterator":
        return _cstl.MapIntVecLong_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntVecLong_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::vector< std::int64_t > >::allocator_type":
        return _cstl.MapIntVecLong_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::vector< std::int64_t > >::key_type const &") -> "std::unordered_map< int,std::vector< std::int64_t > >::size_type":
        return _cstl.MapIntVecLong_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntVecLong_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::vector< std::int64_t > >::key_type const &") -> "std::unordered_map< int,std::vector< std::int64_t > >::iterator":
        return _cstl.MapIntVecLong_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntVecLong

# Register MapIntVecLong in _cstl:
_cstl.MapIntVecLong_swigregister(MapIntVecLong)

class MapIntSetInt(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntSetInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntSetInt___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntSetInt___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::unordered_set< int > >::size_type":
        return _cstl.MapIntSetInt___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::unordered_set< int > >::key_type const &") -> "std::unordered_map< int,std::unordered_set< int > >::mapped_type const &":
        return _cstl.MapIntSetInt___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::unordered_set< int > >::key_type const &") -> "void":
        return _cstl.MapIntSetInt___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::unordered_set< int > >::key_type const &") -> "bool":
        return _cstl.MapIntSetInt_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntSetInt_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntSetInt_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntSetInt_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::unordered_set< int > >::key_type const &") -> "bool":
        return _cstl.MapIntSetInt___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntSetInt_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntSetInt_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntSetInt___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntSetInt_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntSetInt_swiginit(self, _cstl.new_MapIntSetInt(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntSetInt_empty(self)

    def size(self) -> "std::unordered_map< int,std::unordered_set< int > >::size_type":
        return _cstl.MapIntSetInt_size(self)

    def swap(self, v: "MapIntSetInt") -> "void":
        return _cstl.MapIntSetInt_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::unordered_set< int > >::iterator":
        return _cstl.MapIntSetInt_begin(self)

    def end(self) -> "std::unordered_map< int,std::unordered_set< int > >::iterator":
        return _cstl.MapIntSetInt_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntSetInt_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::unordered_set< int > >::allocator_type":
        return _cstl.MapIntSetInt_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::unordered_set< int > >::key_type const &") -> "std::unordered_map< int,std::unordered_set< int > >::size_type":
        return _cstl.MapIntSetInt_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntSetInt_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::unordered_set< int > >::key_type const &") -> "std::unordered_map< int,std::unordered_set< int > >::iterator":
        return _cstl.MapIntSetInt_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntSetInt

# Register MapIntSetInt in _cstl:
_cstl.MapIntSetInt_swigregister(MapIntSetInt)

class MapIntSetStr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntSetStr_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntSetStr___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntSetStr___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::unordered_set< std::string > >::size_type":
        return _cstl.MapIntSetStr___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::unordered_set< std::string > >::key_type const &") -> "std::unordered_map< int,std::unordered_set< std::string > >::mapped_type const &":
        return _cstl.MapIntSetStr___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::unordered_set< std::string > >::key_type const &") -> "void":
        return _cstl.MapIntSetStr___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::unordered_set< std::string > >::key_type const &") -> "bool":
        return _cstl.MapIntSetStr_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntSetStr_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntSetStr_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntSetStr_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::unordered_set< std::string > >::key_type const &") -> "bool":
        return _cstl.MapIntSetStr___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntSetStr_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntSetStr_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntSetStr___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntSetStr_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntSetStr_swiginit(self, _cstl.new_MapIntSetStr(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntSetStr_empty(self)

    def size(self) -> "std::unordered_map< int,std::unordered_set< std::string > >::size_type":
        return _cstl.MapIntSetStr_size(self)

    def swap(self, v: "MapIntSetStr") -> "void":
        return _cstl.MapIntSetStr_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::unordered_set< std::string > >::iterator":
        return _cstl.MapIntSetStr_begin(self)

    def end(self) -> "std::unordered_map< int,std::unordered_set< std::string > >::iterator":
        return _cstl.MapIntSetStr_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntSetStr_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::unordered_set< std::string > >::allocator_type":
        return _cstl.MapIntSetStr_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::unordered_set< std::string > >::key_type const &") -> "std::unordered_map< int,std::unordered_set< std::string > >::size_type":
        return _cstl.MapIntSetStr_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntSetStr_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::unordered_set< std::string > >::key_type const &") -> "std::unordered_map< int,std::unordered_set< std::string > >::iterator":
        return _cstl.MapIntSetStr_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntSetStr

# Register MapIntSetStr in _cstl:
_cstl.MapIntSetStr_swigregister(MapIntSetStr)

class MapIntSetLong(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntSetLong_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntSetLong___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntSetLong___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::unordered_set< std::int64_t > >::size_type":
        return _cstl.MapIntSetLong___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::unordered_set< std::int64_t > >::key_type const &") -> "std::unordered_map< int,std::unordered_set< std::int64_t > >::mapped_type const &":
        return _cstl.MapIntSetLong___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::unordered_set< std::int64_t > >::key_type const &") -> "void":
        return _cstl.MapIntSetLong___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::unordered_set< std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapIntSetLong_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntSetLong_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntSetLong_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntSetLong_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::unordered_set< std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapIntSetLong___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntSetLong_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntSetLong_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntSetLong___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntSetLong_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntSetLong_swiginit(self, _cstl.new_MapIntSetLong(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntSetLong_empty(self)

    def size(self) -> "std::unordered_map< int,std::unordered_set< std::int64_t > >::size_type":
        return _cstl.MapIntSetLong_size(self)

    def swap(self, v: "MapIntSetLong") -> "void":
        return _cstl.MapIntSetLong_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::unordered_set< std::int64_t > >::iterator":
        return _cstl.MapIntSetLong_begin(self)

    def end(self) -> "std::unordered_map< int,std::unordered_set< std::int64_t > >::iterator":
        return _cstl.MapIntSetLong_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntSetLong_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::unordered_set< std::int64_t > >::allocator_type":
        return _cstl.MapIntSetLong_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::unordered_set< std::int64_t > >::key_type const &") -> "std::unordered_map< int,std::unordered_set< std::int64_t > >::size_type":
        return _cstl.MapIntSetLong_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntSetLong_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::unordered_set< std::int64_t > >::key_type const &") -> "std::unordered_map< int,std::unordered_set< std::int64_t > >::iterator":
        return _cstl.MapIntSetLong_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntSetLong

# Register MapIntSetLong in _cstl:
_cstl.MapIntSetLong_swigregister(MapIntSetLong)

class MapIntMapIntInt(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapIntInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntMapIntInt___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntMapIntInt___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::unordered_map< int,int > >::size_type":
        return _cstl.MapIntMapIntInt___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::unordered_map< int,int > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< int,int > >::mapped_type const &":
        return _cstl.MapIntMapIntInt___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::unordered_map< int,int > >::key_type const &") -> "void":
        return _cstl.MapIntMapIntInt___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::unordered_map< int,int > >::key_type const &") -> "bool":
        return _cstl.MapIntMapIntInt_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntMapIntInt_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntMapIntInt_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntMapIntInt_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::unordered_map< int,int > >::key_type const &") -> "bool":
        return _cstl.MapIntMapIntInt___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapIntInt_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapIntInt_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntMapIntInt___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntMapIntInt_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntMapIntInt_swiginit(self, _cstl.new_MapIntMapIntInt(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntMapIntInt_empty(self)

    def size(self) -> "std::unordered_map< int,std::unordered_map< int,int > >::size_type":
        return _cstl.MapIntMapIntInt_size(self)

    def swap(self, v: "MapIntMapIntInt") -> "void":
        return _cstl.MapIntMapIntInt_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::unordered_map< int,int > >::iterator":
        return _cstl.MapIntMapIntInt_begin(self)

    def end(self) -> "std::unordered_map< int,std::unordered_map< int,int > >::iterator":
        return _cstl.MapIntMapIntInt_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntMapIntInt_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::unordered_map< int,int > >::allocator_type":
        return _cstl.MapIntMapIntInt_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::unordered_map< int,int > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< int,int > >::size_type":
        return _cstl.MapIntMapIntInt_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntMapIntInt_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::unordered_map< int,int > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< int,int > >::iterator":
        return _cstl.MapIntMapIntInt_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntMapIntInt

# Register MapIntMapIntInt in _cstl:
_cstl.MapIntMapIntInt_swigregister(MapIntMapIntInt)

class MapIntMapIntStr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapIntStr_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntMapIntStr___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntMapIntStr___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::unordered_map< int,std::string > >::size_type":
        return _cstl.MapIntMapIntStr___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::unordered_map< int,std::string > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< int,std::string > >::mapped_type const &":
        return _cstl.MapIntMapIntStr___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::unordered_map< int,std::string > >::key_type const &") -> "void":
        return _cstl.MapIntMapIntStr___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::unordered_map< int,std::string > >::key_type const &") -> "bool":
        return _cstl.MapIntMapIntStr_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntMapIntStr_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntMapIntStr_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntMapIntStr_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::unordered_map< int,std::string > >::key_type const &") -> "bool":
        return _cstl.MapIntMapIntStr___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapIntStr_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapIntStr_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntMapIntStr___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntMapIntStr_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntMapIntStr_swiginit(self, _cstl.new_MapIntMapIntStr(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntMapIntStr_empty(self)

    def size(self) -> "std::unordered_map< int,std::unordered_map< int,std::string > >::size_type":
        return _cstl.MapIntMapIntStr_size(self)

    def swap(self, v: "MapIntMapIntStr") -> "void":
        return _cstl.MapIntMapIntStr_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::unordered_map< int,std::string > >::iterator":
        return _cstl.MapIntMapIntStr_begin(self)

    def end(self) -> "std::unordered_map< int,std::unordered_map< int,std::string > >::iterator":
        return _cstl.MapIntMapIntStr_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntMapIntStr_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::unordered_map< int,std::string > >::allocator_type":
        return _cstl.MapIntMapIntStr_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::unordered_map< int,std::string > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< int,std::string > >::size_type":
        return _cstl.MapIntMapIntStr_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntMapIntStr_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::unordered_map< int,std::string > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< int,std::string > >::iterator":
        return _cstl.MapIntMapIntStr_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntMapIntStr

# Register MapIntMapIntStr in _cstl:
_cstl.MapIntMapIntStr_swigregister(MapIntMapIntStr)

class MapIntMapIntFloat(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapIntFloat_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntMapIntFloat___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntMapIntFloat___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::unordered_map< int,float > >::size_type":
        return _cstl.MapIntMapIntFloat___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::unordered_map< int,float > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< int,float > >::mapped_type const &":
        return _cstl.MapIntMapIntFloat___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::unordered_map< int,float > >::key_type const &") -> "void":
        return _cstl.MapIntMapIntFloat___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::unordered_map< int,float > >::key_type const &") -> "bool":
        return _cstl.MapIntMapIntFloat_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntMapIntFloat_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntMapIntFloat_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntMapIntFloat_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::unordered_map< int,float > >::key_type const &") -> "bool":
        return _cstl.MapIntMapIntFloat___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapIntFloat_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapIntFloat_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntMapIntFloat___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntMapIntFloat_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntMapIntFloat_swiginit(self, _cstl.new_MapIntMapIntFloat(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntMapIntFloat_empty(self)

    def size(self) -> "std::unordered_map< int,std::unordered_map< int,float > >::size_type":
        return _cstl.MapIntMapIntFloat_size(self)

    def swap(self, v: "MapIntMapIntFloat") -> "void":
        return _cstl.MapIntMapIntFloat_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::unordered_map< int,float > >::iterator":
        return _cstl.MapIntMapIntFloat_begin(self)

    def end(self) -> "std::unordered_map< int,std::unordered_map< int,float > >::iterator":
        return _cstl.MapIntMapIntFloat_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntMapIntFloat_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::unordered_map< int,float > >::allocator_type":
        return _cstl.MapIntMapIntFloat_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::unordered_map< int,float > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< int,float > >::size_type":
        return _cstl.MapIntMapIntFloat_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntMapIntFloat_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::unordered_map< int,float > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< int,float > >::iterator":
        return _cstl.MapIntMapIntFloat_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntMapIntFloat

# Register MapIntMapIntFloat in _cstl:
_cstl.MapIntMapIntFloat_swigregister(MapIntMapIntFloat)

class MapIntMapIntDouble(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapIntDouble_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntMapIntDouble___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntMapIntDouble___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::unordered_map< int,double > >::size_type":
        return _cstl.MapIntMapIntDouble___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::unordered_map< int,double > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< int,double > >::mapped_type const &":
        return _cstl.MapIntMapIntDouble___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::unordered_map< int,double > >::key_type const &") -> "void":
        return _cstl.MapIntMapIntDouble___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::unordered_map< int,double > >::key_type const &") -> "bool":
        return _cstl.MapIntMapIntDouble_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntMapIntDouble_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntMapIntDouble_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntMapIntDouble_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::unordered_map< int,double > >::key_type const &") -> "bool":
        return _cstl.MapIntMapIntDouble___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapIntDouble_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapIntDouble_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntMapIntDouble___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntMapIntDouble_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntMapIntDouble_swiginit(self, _cstl.new_MapIntMapIntDouble(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntMapIntDouble_empty(self)

    def size(self) -> "std::unordered_map< int,std::unordered_map< int,double > >::size_type":
        return _cstl.MapIntMapIntDouble_size(self)

    def swap(self, v: "MapIntMapIntDouble") -> "void":
        return _cstl.MapIntMapIntDouble_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::unordered_map< int,double > >::iterator":
        return _cstl.MapIntMapIntDouble_begin(self)

    def end(self) -> "std::unordered_map< int,std::unordered_map< int,double > >::iterator":
        return _cstl.MapIntMapIntDouble_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntMapIntDouble_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::unordered_map< int,double > >::allocator_type":
        return _cstl.MapIntMapIntDouble_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::unordered_map< int,double > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< int,double > >::size_type":
        return _cstl.MapIntMapIntDouble_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntMapIntDouble_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::unordered_map< int,double > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< int,double > >::iterator":
        return _cstl.MapIntMapIntDouble_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntMapIntDouble

# Register MapIntMapIntDouble in _cstl:
_cstl.MapIntMapIntDouble_swigregister(MapIntMapIntDouble)

class MapIntMapIntBool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapIntBool_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntMapIntBool___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntMapIntBool___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::unordered_map< int,bool > >::size_type":
        return _cstl.MapIntMapIntBool___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::unordered_map< int,bool > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< int,bool > >::mapped_type const &":
        return _cstl.MapIntMapIntBool___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::unordered_map< int,bool > >::key_type const &") -> "void":
        return _cstl.MapIntMapIntBool___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::unordered_map< int,bool > >::key_type const &") -> "bool":
        return _cstl.MapIntMapIntBool_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntMapIntBool_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntMapIntBool_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntMapIntBool_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::unordered_map< int,bool > >::key_type const &") -> "bool":
        return _cstl.MapIntMapIntBool___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapIntBool_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapIntBool_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntMapIntBool___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntMapIntBool_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntMapIntBool_swiginit(self, _cstl.new_MapIntMapIntBool(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntMapIntBool_empty(self)

    def size(self) -> "std::unordered_map< int,std::unordered_map< int,bool > >::size_type":
        return _cstl.MapIntMapIntBool_size(self)

    def swap(self, v: "MapIntMapIntBool") -> "void":
        return _cstl.MapIntMapIntBool_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::unordered_map< int,bool > >::iterator":
        return _cstl.MapIntMapIntBool_begin(self)

    def end(self) -> "std::unordered_map< int,std::unordered_map< int,bool > >::iterator":
        return _cstl.MapIntMapIntBool_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntMapIntBool_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::unordered_map< int,bool > >::allocator_type":
        return _cstl.MapIntMapIntBool_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::unordered_map< int,bool > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< int,bool > >::size_type":
        return _cstl.MapIntMapIntBool_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntMapIntBool_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::unordered_map< int,bool > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< int,bool > >::iterator":
        return _cstl.MapIntMapIntBool_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntMapIntBool

# Register MapIntMapIntBool in _cstl:
_cstl.MapIntMapIntBool_swigregister(MapIntMapIntBool)

class MapIntMapIntLong(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapIntLong_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntMapIntLong___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntMapIntLong___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::unordered_map< int,std::int64_t > >::size_type":
        return _cstl.MapIntMapIntLong___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::unordered_map< int,std::int64_t > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< int,std::int64_t > >::mapped_type const &":
        return _cstl.MapIntMapIntLong___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::unordered_map< int,std::int64_t > >::key_type const &") -> "void":
        return _cstl.MapIntMapIntLong___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::unordered_map< int,std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapIntMapIntLong_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntMapIntLong_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntMapIntLong_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntMapIntLong_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::unordered_map< int,std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapIntMapIntLong___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapIntLong_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapIntLong_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntMapIntLong___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntMapIntLong_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntMapIntLong_swiginit(self, _cstl.new_MapIntMapIntLong(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntMapIntLong_empty(self)

    def size(self) -> "std::unordered_map< int,std::unordered_map< int,std::int64_t > >::size_type":
        return _cstl.MapIntMapIntLong_size(self)

    def swap(self, v: "MapIntMapIntLong") -> "void":
        return _cstl.MapIntMapIntLong_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::unordered_map< int,std::int64_t > >::iterator":
        return _cstl.MapIntMapIntLong_begin(self)

    def end(self) -> "std::unordered_map< int,std::unordered_map< int,std::int64_t > >::iterator":
        return _cstl.MapIntMapIntLong_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntMapIntLong_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::unordered_map< int,std::int64_t > >::allocator_type":
        return _cstl.MapIntMapIntLong_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::unordered_map< int,std::int64_t > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< int,std::int64_t > >::size_type":
        return _cstl.MapIntMapIntLong_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntMapIntLong_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::unordered_map< int,std::int64_t > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< int,std::int64_t > >::iterator":
        return _cstl.MapIntMapIntLong_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntMapIntLong

# Register MapIntMapIntLong in _cstl:
_cstl.MapIntMapIntLong_swigregister(MapIntMapIntLong)

class MapIntMapStrInt(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapStrInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntMapStrInt___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntMapStrInt___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::unordered_map< std::string,int > >::size_type":
        return _cstl.MapIntMapStrInt___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::unordered_map< std::string,int > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::string,int > >::mapped_type const &":
        return _cstl.MapIntMapStrInt___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::unordered_map< std::string,int > >::key_type const &") -> "void":
        return _cstl.MapIntMapStrInt___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::unordered_map< std::string,int > >::key_type const &") -> "bool":
        return _cstl.MapIntMapStrInt_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntMapStrInt_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntMapStrInt_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntMapStrInt_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::unordered_map< std::string,int > >::key_type const &") -> "bool":
        return _cstl.MapIntMapStrInt___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapStrInt_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapStrInt_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntMapStrInt___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntMapStrInt_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntMapStrInt_swiginit(self, _cstl.new_MapIntMapStrInt(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntMapStrInt_empty(self)

    def size(self) -> "std::unordered_map< int,std::unordered_map< std::string,int > >::size_type":
        return _cstl.MapIntMapStrInt_size(self)

    def swap(self, v: "MapIntMapStrInt") -> "void":
        return _cstl.MapIntMapStrInt_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::unordered_map< std::string,int > >::iterator":
        return _cstl.MapIntMapStrInt_begin(self)

    def end(self) -> "std::unordered_map< int,std::unordered_map< std::string,int > >::iterator":
        return _cstl.MapIntMapStrInt_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntMapStrInt_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::unordered_map< std::string,int > >::allocator_type":
        return _cstl.MapIntMapStrInt_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::unordered_map< std::string,int > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::string,int > >::size_type":
        return _cstl.MapIntMapStrInt_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntMapStrInt_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::unordered_map< std::string,int > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::string,int > >::iterator":
        return _cstl.MapIntMapStrInt_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntMapStrInt

# Register MapIntMapStrInt in _cstl:
_cstl.MapIntMapStrInt_swigregister(MapIntMapStrInt)

class MapIntMapStrStr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapStrStr_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntMapStrStr___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntMapStrStr___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::unordered_map< std::string,std::string > >::size_type":
        return _cstl.MapIntMapStrStr___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::unordered_map< std::string,std::string > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::string,std::string > >::mapped_type const &":
        return _cstl.MapIntMapStrStr___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::unordered_map< std::string,std::string > >::key_type const &") -> "void":
        return _cstl.MapIntMapStrStr___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::unordered_map< std::string,std::string > >::key_type const &") -> "bool":
        return _cstl.MapIntMapStrStr_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntMapStrStr_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntMapStrStr_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntMapStrStr_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::unordered_map< std::string,std::string > >::key_type const &") -> "bool":
        return _cstl.MapIntMapStrStr___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapStrStr_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapStrStr_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntMapStrStr___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntMapStrStr_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntMapStrStr_swiginit(self, _cstl.new_MapIntMapStrStr(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntMapStrStr_empty(self)

    def size(self) -> "std::unordered_map< int,std::unordered_map< std::string,std::string > >::size_type":
        return _cstl.MapIntMapStrStr_size(self)

    def swap(self, v: "MapIntMapStrStr") -> "void":
        return _cstl.MapIntMapStrStr_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::unordered_map< std::string,std::string > >::iterator":
        return _cstl.MapIntMapStrStr_begin(self)

    def end(self) -> "std::unordered_map< int,std::unordered_map< std::string,std::string > >::iterator":
        return _cstl.MapIntMapStrStr_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntMapStrStr_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::unordered_map< std::string,std::string > >::allocator_type":
        return _cstl.MapIntMapStrStr_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::unordered_map< std::string,std::string > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::string,std::string > >::size_type":
        return _cstl.MapIntMapStrStr_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntMapStrStr_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::unordered_map< std::string,std::string > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::string,std::string > >::iterator":
        return _cstl.MapIntMapStrStr_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntMapStrStr

# Register MapIntMapStrStr in _cstl:
_cstl.MapIntMapStrStr_swigregister(MapIntMapStrStr)

class MapIntMapStrFloat(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapStrFloat_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntMapStrFloat___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntMapStrFloat___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::unordered_map< std::string,float > >::size_type":
        return _cstl.MapIntMapStrFloat___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::unordered_map< std::string,float > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::string,float > >::mapped_type const &":
        return _cstl.MapIntMapStrFloat___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::unordered_map< std::string,float > >::key_type const &") -> "void":
        return _cstl.MapIntMapStrFloat___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::unordered_map< std::string,float > >::key_type const &") -> "bool":
        return _cstl.MapIntMapStrFloat_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntMapStrFloat_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntMapStrFloat_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntMapStrFloat_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::unordered_map< std::string,float > >::key_type const &") -> "bool":
        return _cstl.MapIntMapStrFloat___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapStrFloat_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapStrFloat_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntMapStrFloat___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntMapStrFloat_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntMapStrFloat_swiginit(self, _cstl.new_MapIntMapStrFloat(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntMapStrFloat_empty(self)

    def size(self) -> "std::unordered_map< int,std::unordered_map< std::string,float > >::size_type":
        return _cstl.MapIntMapStrFloat_size(self)

    def swap(self, v: "MapIntMapStrFloat") -> "void":
        return _cstl.MapIntMapStrFloat_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::unordered_map< std::string,float > >::iterator":
        return _cstl.MapIntMapStrFloat_begin(self)

    def end(self) -> "std::unordered_map< int,std::unordered_map< std::string,float > >::iterator":
        return _cstl.MapIntMapStrFloat_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntMapStrFloat_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::unordered_map< std::string,float > >::allocator_type":
        return _cstl.MapIntMapStrFloat_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::unordered_map< std::string,float > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::string,float > >::size_type":
        return _cstl.MapIntMapStrFloat_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntMapStrFloat_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::unordered_map< std::string,float > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::string,float > >::iterator":
        return _cstl.MapIntMapStrFloat_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntMapStrFloat

# Register MapIntMapStrFloat in _cstl:
_cstl.MapIntMapStrFloat_swigregister(MapIntMapStrFloat)

class MapIntMapStrDouble(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapStrDouble_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntMapStrDouble___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntMapStrDouble___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::unordered_map< std::string,double > >::size_type":
        return _cstl.MapIntMapStrDouble___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::unordered_map< std::string,double > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::string,double > >::mapped_type const &":
        return _cstl.MapIntMapStrDouble___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::unordered_map< std::string,double > >::key_type const &") -> "void":
        return _cstl.MapIntMapStrDouble___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::unordered_map< std::string,double > >::key_type const &") -> "bool":
        return _cstl.MapIntMapStrDouble_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntMapStrDouble_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntMapStrDouble_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntMapStrDouble_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::unordered_map< std::string,double > >::key_type const &") -> "bool":
        return _cstl.MapIntMapStrDouble___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapStrDouble_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapStrDouble_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntMapStrDouble___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntMapStrDouble_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntMapStrDouble_swiginit(self, _cstl.new_MapIntMapStrDouble(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntMapStrDouble_empty(self)

    def size(self) -> "std::unordered_map< int,std::unordered_map< std::string,double > >::size_type":
        return _cstl.MapIntMapStrDouble_size(self)

    def swap(self, v: "MapIntMapStrDouble") -> "void":
        return _cstl.MapIntMapStrDouble_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::unordered_map< std::string,double > >::iterator":
        return _cstl.MapIntMapStrDouble_begin(self)

    def end(self) -> "std::unordered_map< int,std::unordered_map< std::string,double > >::iterator":
        return _cstl.MapIntMapStrDouble_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntMapStrDouble_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::unordered_map< std::string,double > >::allocator_type":
        return _cstl.MapIntMapStrDouble_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::unordered_map< std::string,double > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::string,double > >::size_type":
        return _cstl.MapIntMapStrDouble_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntMapStrDouble_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::unordered_map< std::string,double > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::string,double > >::iterator":
        return _cstl.MapIntMapStrDouble_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntMapStrDouble

# Register MapIntMapStrDouble in _cstl:
_cstl.MapIntMapStrDouble_swigregister(MapIntMapStrDouble)

class MapIntMapStrBool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapStrBool_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntMapStrBool___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntMapStrBool___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::unordered_map< std::string,bool > >::size_type":
        return _cstl.MapIntMapStrBool___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::unordered_map< std::string,bool > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::string,bool > >::mapped_type const &":
        return _cstl.MapIntMapStrBool___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::unordered_map< std::string,bool > >::key_type const &") -> "void":
        return _cstl.MapIntMapStrBool___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::unordered_map< std::string,bool > >::key_type const &") -> "bool":
        return _cstl.MapIntMapStrBool_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntMapStrBool_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntMapStrBool_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntMapStrBool_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::unordered_map< std::string,bool > >::key_type const &") -> "bool":
        return _cstl.MapIntMapStrBool___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapStrBool_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapStrBool_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntMapStrBool___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntMapStrBool_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntMapStrBool_swiginit(self, _cstl.new_MapIntMapStrBool(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntMapStrBool_empty(self)

    def size(self) -> "std::unordered_map< int,std::unordered_map< std::string,bool > >::size_type":
        return _cstl.MapIntMapStrBool_size(self)

    def swap(self, v: "MapIntMapStrBool") -> "void":
        return _cstl.MapIntMapStrBool_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::unordered_map< std::string,bool > >::iterator":
        return _cstl.MapIntMapStrBool_begin(self)

    def end(self) -> "std::unordered_map< int,std::unordered_map< std::string,bool > >::iterator":
        return _cstl.MapIntMapStrBool_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntMapStrBool_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::unordered_map< std::string,bool > >::allocator_type":
        return _cstl.MapIntMapStrBool_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::unordered_map< std::string,bool > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::string,bool > >::size_type":
        return _cstl.MapIntMapStrBool_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntMapStrBool_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::unordered_map< std::string,bool > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::string,bool > >::iterator":
        return _cstl.MapIntMapStrBool_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntMapStrBool

# Register MapIntMapStrBool in _cstl:
_cstl.MapIntMapStrBool_swigregister(MapIntMapStrBool)

class MapIntMapStrLong(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapStrLong_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntMapStrLong___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntMapStrLong___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::unordered_map< std::string,std::int64_t > >::size_type":
        return _cstl.MapIntMapStrLong___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::unordered_map< std::string,std::int64_t > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::string,std::int64_t > >::mapped_type const &":
        return _cstl.MapIntMapStrLong___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::unordered_map< std::string,std::int64_t > >::key_type const &") -> "void":
        return _cstl.MapIntMapStrLong___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::unordered_map< std::string,std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapIntMapStrLong_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntMapStrLong_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntMapStrLong_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntMapStrLong_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::unordered_map< std::string,std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapIntMapStrLong___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapStrLong_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapStrLong_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntMapStrLong___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntMapStrLong_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntMapStrLong_swiginit(self, _cstl.new_MapIntMapStrLong(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntMapStrLong_empty(self)

    def size(self) -> "std::unordered_map< int,std::unordered_map< std::string,std::int64_t > >::size_type":
        return _cstl.MapIntMapStrLong_size(self)

    def swap(self, v: "MapIntMapStrLong") -> "void":
        return _cstl.MapIntMapStrLong_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::unordered_map< std::string,std::int64_t > >::iterator":
        return _cstl.MapIntMapStrLong_begin(self)

    def end(self) -> "std::unordered_map< int,std::unordered_map< std::string,std::int64_t > >::iterator":
        return _cstl.MapIntMapStrLong_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntMapStrLong_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::unordered_map< std::string,std::int64_t > >::allocator_type":
        return _cstl.MapIntMapStrLong_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::unordered_map< std::string,std::int64_t > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::string,std::int64_t > >::size_type":
        return _cstl.MapIntMapStrLong_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntMapStrLong_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::unordered_map< std::string,std::int64_t > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::string,std::int64_t > >::iterator":
        return _cstl.MapIntMapStrLong_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntMapStrLong

# Register MapIntMapStrLong in _cstl:
_cstl.MapIntMapStrLong_swigregister(MapIntMapStrLong)

class MapIntMapLongInt(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapLongInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntMapLongInt___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntMapLongInt___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,int > >::size_type":
        return _cstl.MapIntMapLongInt___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::unordered_map< std::int64_t,int > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::int64_t,int > >::mapped_type const &":
        return _cstl.MapIntMapLongInt___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::unordered_map< std::int64_t,int > >::key_type const &") -> "void":
        return _cstl.MapIntMapLongInt___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::unordered_map< std::int64_t,int > >::key_type const &") -> "bool":
        return _cstl.MapIntMapLongInt_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntMapLongInt_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntMapLongInt_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntMapLongInt_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::unordered_map< std::int64_t,int > >::key_type const &") -> "bool":
        return _cstl.MapIntMapLongInt___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapLongInt_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapLongInt_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntMapLongInt___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntMapLongInt_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntMapLongInt_swiginit(self, _cstl.new_MapIntMapLongInt(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntMapLongInt_empty(self)

    def size(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,int > >::size_type":
        return _cstl.MapIntMapLongInt_size(self)

    def swap(self, v: "MapIntMapLongInt") -> "void":
        return _cstl.MapIntMapLongInt_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,int > >::iterator":
        return _cstl.MapIntMapLongInt_begin(self)

    def end(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,int > >::iterator":
        return _cstl.MapIntMapLongInt_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntMapLongInt_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,int > >::allocator_type":
        return _cstl.MapIntMapLongInt_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::unordered_map< std::int64_t,int > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::int64_t,int > >::size_type":
        return _cstl.MapIntMapLongInt_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntMapLongInt_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::unordered_map< std::int64_t,int > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::int64_t,int > >::iterator":
        return _cstl.MapIntMapLongInt_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntMapLongInt

# Register MapIntMapLongInt in _cstl:
_cstl.MapIntMapLongInt_swigregister(MapIntMapLongInt)

class MapIntMapLongStr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapLongStr_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntMapLongStr___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntMapLongStr___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,std::string > >::size_type":
        return _cstl.MapIntMapLongStr___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::unordered_map< std::int64_t,std::string > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::int64_t,std::string > >::mapped_type const &":
        return _cstl.MapIntMapLongStr___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::unordered_map< std::int64_t,std::string > >::key_type const &") -> "void":
        return _cstl.MapIntMapLongStr___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::unordered_map< std::int64_t,std::string > >::key_type const &") -> "bool":
        return _cstl.MapIntMapLongStr_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntMapLongStr_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntMapLongStr_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntMapLongStr_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::unordered_map< std::int64_t,std::string > >::key_type const &") -> "bool":
        return _cstl.MapIntMapLongStr___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapLongStr_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapLongStr_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntMapLongStr___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntMapLongStr_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntMapLongStr_swiginit(self, _cstl.new_MapIntMapLongStr(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntMapLongStr_empty(self)

    def size(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,std::string > >::size_type":
        return _cstl.MapIntMapLongStr_size(self)

    def swap(self, v: "MapIntMapLongStr") -> "void":
        return _cstl.MapIntMapLongStr_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,std::string > >::iterator":
        return _cstl.MapIntMapLongStr_begin(self)

    def end(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,std::string > >::iterator":
        return _cstl.MapIntMapLongStr_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntMapLongStr_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,std::string > >::allocator_type":
        return _cstl.MapIntMapLongStr_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::unordered_map< std::int64_t,std::string > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::int64_t,std::string > >::size_type":
        return _cstl.MapIntMapLongStr_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntMapLongStr_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::unordered_map< std::int64_t,std::string > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::int64_t,std::string > >::iterator":
        return _cstl.MapIntMapLongStr_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntMapLongStr

# Register MapIntMapLongStr in _cstl:
_cstl.MapIntMapLongStr_swigregister(MapIntMapLongStr)

class MapIntMapLongFloat(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapLongFloat_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntMapLongFloat___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntMapLongFloat___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,float > >::size_type":
        return _cstl.MapIntMapLongFloat___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::unordered_map< std::int64_t,float > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::int64_t,float > >::mapped_type const &":
        return _cstl.MapIntMapLongFloat___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::unordered_map< std::int64_t,float > >::key_type const &") -> "void":
        return _cstl.MapIntMapLongFloat___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::unordered_map< std::int64_t,float > >::key_type const &") -> "bool":
        return _cstl.MapIntMapLongFloat_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntMapLongFloat_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntMapLongFloat_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntMapLongFloat_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::unordered_map< std::int64_t,float > >::key_type const &") -> "bool":
        return _cstl.MapIntMapLongFloat___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapLongFloat_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapLongFloat_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntMapLongFloat___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntMapLongFloat_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntMapLongFloat_swiginit(self, _cstl.new_MapIntMapLongFloat(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntMapLongFloat_empty(self)

    def size(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,float > >::size_type":
        return _cstl.MapIntMapLongFloat_size(self)

    def swap(self, v: "MapIntMapLongFloat") -> "void":
        return _cstl.MapIntMapLongFloat_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,float > >::iterator":
        return _cstl.MapIntMapLongFloat_begin(self)

    def end(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,float > >::iterator":
        return _cstl.MapIntMapLongFloat_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntMapLongFloat_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,float > >::allocator_type":
        return _cstl.MapIntMapLongFloat_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::unordered_map< std::int64_t,float > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::int64_t,float > >::size_type":
        return _cstl.MapIntMapLongFloat_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntMapLongFloat_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::unordered_map< std::int64_t,float > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::int64_t,float > >::iterator":
        return _cstl.MapIntMapLongFloat_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntMapLongFloat

# Register MapIntMapLongFloat in _cstl:
_cstl.MapIntMapLongFloat_swigregister(MapIntMapLongFloat)

class MapIntMapLongDouble(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapLongDouble_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntMapLongDouble___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntMapLongDouble___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,double > >::size_type":
        return _cstl.MapIntMapLongDouble___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::unordered_map< std::int64_t,double > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::int64_t,double > >::mapped_type const &":
        return _cstl.MapIntMapLongDouble___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::unordered_map< std::int64_t,double > >::key_type const &") -> "void":
        return _cstl.MapIntMapLongDouble___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::unordered_map< std::int64_t,double > >::key_type const &") -> "bool":
        return _cstl.MapIntMapLongDouble_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntMapLongDouble_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntMapLongDouble_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntMapLongDouble_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::unordered_map< std::int64_t,double > >::key_type const &") -> "bool":
        return _cstl.MapIntMapLongDouble___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapLongDouble_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapLongDouble_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntMapLongDouble___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntMapLongDouble_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntMapLongDouble_swiginit(self, _cstl.new_MapIntMapLongDouble(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntMapLongDouble_empty(self)

    def size(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,double > >::size_type":
        return _cstl.MapIntMapLongDouble_size(self)

    def swap(self, v: "MapIntMapLongDouble") -> "void":
        return _cstl.MapIntMapLongDouble_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,double > >::iterator":
        return _cstl.MapIntMapLongDouble_begin(self)

    def end(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,double > >::iterator":
        return _cstl.MapIntMapLongDouble_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntMapLongDouble_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,double > >::allocator_type":
        return _cstl.MapIntMapLongDouble_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::unordered_map< std::int64_t,double > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::int64_t,double > >::size_type":
        return _cstl.MapIntMapLongDouble_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntMapLongDouble_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::unordered_map< std::int64_t,double > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::int64_t,double > >::iterator":
        return _cstl.MapIntMapLongDouble_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntMapLongDouble

# Register MapIntMapLongDouble in _cstl:
_cstl.MapIntMapLongDouble_swigregister(MapIntMapLongDouble)

class MapIntMapLongBool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapLongBool_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntMapLongBool___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntMapLongBool___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,bool > >::size_type":
        return _cstl.MapIntMapLongBool___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::unordered_map< std::int64_t,bool > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::int64_t,bool > >::mapped_type const &":
        return _cstl.MapIntMapLongBool___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::unordered_map< std::int64_t,bool > >::key_type const &") -> "void":
        return _cstl.MapIntMapLongBool___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::unordered_map< std::int64_t,bool > >::key_type const &") -> "bool":
        return _cstl.MapIntMapLongBool_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntMapLongBool_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntMapLongBool_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntMapLongBool_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::unordered_map< std::int64_t,bool > >::key_type const &") -> "bool":
        return _cstl.MapIntMapLongBool___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapLongBool_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapLongBool_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntMapLongBool___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntMapLongBool_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntMapLongBool_swiginit(self, _cstl.new_MapIntMapLongBool(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntMapLongBool_empty(self)

    def size(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,bool > >::size_type":
        return _cstl.MapIntMapLongBool_size(self)

    def swap(self, v: "MapIntMapLongBool") -> "void":
        return _cstl.MapIntMapLongBool_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,bool > >::iterator":
        return _cstl.MapIntMapLongBool_begin(self)

    def end(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,bool > >::iterator":
        return _cstl.MapIntMapLongBool_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntMapLongBool_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,bool > >::allocator_type":
        return _cstl.MapIntMapLongBool_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::unordered_map< std::int64_t,bool > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::int64_t,bool > >::size_type":
        return _cstl.MapIntMapLongBool_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntMapLongBool_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::unordered_map< std::int64_t,bool > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::int64_t,bool > >::iterator":
        return _cstl.MapIntMapLongBool_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntMapLongBool

# Register MapIntMapLongBool in _cstl:
_cstl.MapIntMapLongBool_swigregister(MapIntMapLongBool)

class MapIntMapLongLong(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapLongLong_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapIntMapLongLong___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapIntMapLongLong___bool__(self)

    def __len__(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,std::int64_t > >::size_type":
        return _cstl.MapIntMapLongLong___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< int,std::unordered_map< std::int64_t,std::int64_t > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::int64_t,std::int64_t > >::mapped_type const &":
        return _cstl.MapIntMapLongLong___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< int,std::unordered_map< std::int64_t,std::int64_t > >::key_type const &") -> "void":
        return _cstl.MapIntMapLongLong___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< int,std::unordered_map< std::int64_t,std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapIntMapLongLong_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapIntMapLongLong_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapIntMapLongLong_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapIntMapLongLong_items(self)

    def __contains__(self, key: "std::unordered_map< int,std::unordered_map< std::int64_t,std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapIntMapLongLong___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapLongLong_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapIntMapLongLong_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapIntMapLongLong___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapIntMapLongLong_asdict(self)

    def __init__(self, *args):
        _cstl.MapIntMapLongLong_swiginit(self, _cstl.new_MapIntMapLongLong(*args))

    def empty(self) -> "bool":
        return _cstl.MapIntMapLongLong_empty(self)

    def size(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,std::int64_t > >::size_type":
        return _cstl.MapIntMapLongLong_size(self)

    def swap(self, v: "MapIntMapLongLong") -> "void":
        return _cstl.MapIntMapLongLong_swap(self, v)

    def begin(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,std::int64_t > >::iterator":
        return _cstl.MapIntMapLongLong_begin(self)

    def end(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,std::int64_t > >::iterator":
        return _cstl.MapIntMapLongLong_end(self)

    def clear(self) -> "void":
        return _cstl.MapIntMapLongLong_clear(self)

    def get_allocator(self) -> "std::unordered_map< int,std::unordered_map< std::int64_t,std::int64_t > >::allocator_type":
        return _cstl.MapIntMapLongLong_get_allocator(self)

    def count(self, x: "std::unordered_map< int,std::unordered_map< std::int64_t,std::int64_t > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::int64_t,std::int64_t > >::size_type":
        return _cstl.MapIntMapLongLong_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapIntMapLongLong_erase(self, *args)

    def find(self, x: "std::unordered_map< int,std::unordered_map< std::int64_t,std::int64_t > >::key_type const &") -> "std::unordered_map< int,std::unordered_map< std::int64_t,std::int64_t > >::iterator":
        return _cstl.MapIntMapLongLong_find(self, x)
    __swig_destroy__ = _cstl.delete_MapIntMapLongLong

# Register MapIntMapLongLong in _cstl:
_cstl.MapIntMapLongLong_swigregister(MapIntMapLongLong)

class MapStrVecInt(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrVecInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrVecInt___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrVecInt___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::vector< int > >::size_type":
        return _cstl.MapStrVecInt___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::vector< int > >::key_type const &") -> "std::unordered_map< std::string,std::vector< int > >::mapped_type const &":
        return _cstl.MapStrVecInt___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::vector< int > >::key_type const &") -> "void":
        return _cstl.MapStrVecInt___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::vector< int > >::key_type const &") -> "bool":
        return _cstl.MapStrVecInt_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrVecInt_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrVecInt_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrVecInt_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::vector< int > >::key_type const &") -> "bool":
        return _cstl.MapStrVecInt___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrVecInt_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrVecInt_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrVecInt___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrVecInt_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrVecInt_swiginit(self, _cstl.new_MapStrVecInt(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrVecInt_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::vector< int > >::size_type":
        return _cstl.MapStrVecInt_size(self)

    def swap(self, v: "MapStrVecInt") -> "void":
        return _cstl.MapStrVecInt_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::vector< int > >::iterator":
        return _cstl.MapStrVecInt_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::vector< int > >::iterator":
        return _cstl.MapStrVecInt_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrVecInt_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::vector< int > >::allocator_type":
        return _cstl.MapStrVecInt_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::vector< int > >::key_type const &") -> "std::unordered_map< std::string,std::vector< int > >::size_type":
        return _cstl.MapStrVecInt_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrVecInt_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::vector< int > >::key_type const &") -> "std::unordered_map< std::string,std::vector< int > >::iterator":
        return _cstl.MapStrVecInt_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrVecInt

# Register MapStrVecInt in _cstl:
_cstl.MapStrVecInt_swigregister(MapStrVecInt)

class MapStrVecStr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrVecStr_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrVecStr___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrVecStr___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::vector< std::string > >::size_type":
        return _cstl.MapStrVecStr___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::vector< std::string > >::key_type const &") -> "std::unordered_map< std::string,std::vector< std::string > >::mapped_type const &":
        return _cstl.MapStrVecStr___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::vector< std::string > >::key_type const &") -> "void":
        return _cstl.MapStrVecStr___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::vector< std::string > >::key_type const &") -> "bool":
        return _cstl.MapStrVecStr_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrVecStr_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrVecStr_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrVecStr_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::vector< std::string > >::key_type const &") -> "bool":
        return _cstl.MapStrVecStr___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrVecStr_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrVecStr_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrVecStr___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrVecStr_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrVecStr_swiginit(self, _cstl.new_MapStrVecStr(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrVecStr_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::vector< std::string > >::size_type":
        return _cstl.MapStrVecStr_size(self)

    def swap(self, v: "MapStrVecStr") -> "void":
        return _cstl.MapStrVecStr_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::vector< std::string > >::iterator":
        return _cstl.MapStrVecStr_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::vector< std::string > >::iterator":
        return _cstl.MapStrVecStr_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrVecStr_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::vector< std::string > >::allocator_type":
        return _cstl.MapStrVecStr_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::vector< std::string > >::key_type const &") -> "std::unordered_map< std::string,std::vector< std::string > >::size_type":
        return _cstl.MapStrVecStr_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrVecStr_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::vector< std::string > >::key_type const &") -> "std::unordered_map< std::string,std::vector< std::string > >::iterator":
        return _cstl.MapStrVecStr_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrVecStr

# Register MapStrVecStr in _cstl:
_cstl.MapStrVecStr_swigregister(MapStrVecStr)

class MapStrVecFloat(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrVecFloat_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrVecFloat___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrVecFloat___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::vector< float > >::size_type":
        return _cstl.MapStrVecFloat___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::vector< float > >::key_type const &") -> "std::unordered_map< std::string,std::vector< float > >::mapped_type const &":
        return _cstl.MapStrVecFloat___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::vector< float > >::key_type const &") -> "void":
        return _cstl.MapStrVecFloat___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::vector< float > >::key_type const &") -> "bool":
        return _cstl.MapStrVecFloat_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrVecFloat_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrVecFloat_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrVecFloat_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::vector< float > >::key_type const &") -> "bool":
        return _cstl.MapStrVecFloat___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrVecFloat_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrVecFloat_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrVecFloat___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrVecFloat_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrVecFloat_swiginit(self, _cstl.new_MapStrVecFloat(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrVecFloat_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::vector< float > >::size_type":
        return _cstl.MapStrVecFloat_size(self)

    def swap(self, v: "MapStrVecFloat") -> "void":
        return _cstl.MapStrVecFloat_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::vector< float > >::iterator":
        return _cstl.MapStrVecFloat_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::vector< float > >::iterator":
        return _cstl.MapStrVecFloat_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrVecFloat_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::vector< float > >::allocator_type":
        return _cstl.MapStrVecFloat_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::vector< float > >::key_type const &") -> "std::unordered_map< std::string,std::vector< float > >::size_type":
        return _cstl.MapStrVecFloat_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrVecFloat_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::vector< float > >::key_type const &") -> "std::unordered_map< std::string,std::vector< float > >::iterator":
        return _cstl.MapStrVecFloat_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrVecFloat

# Register MapStrVecFloat in _cstl:
_cstl.MapStrVecFloat_swigregister(MapStrVecFloat)

class MapStrVecDouble(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrVecDouble_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrVecDouble___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrVecDouble___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::vector< double > >::size_type":
        return _cstl.MapStrVecDouble___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::vector< double > >::key_type const &") -> "std::unordered_map< std::string,std::vector< double > >::mapped_type const &":
        return _cstl.MapStrVecDouble___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::vector< double > >::key_type const &") -> "void":
        return _cstl.MapStrVecDouble___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::vector< double > >::key_type const &") -> "bool":
        return _cstl.MapStrVecDouble_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrVecDouble_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrVecDouble_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrVecDouble_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::vector< double > >::key_type const &") -> "bool":
        return _cstl.MapStrVecDouble___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrVecDouble_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrVecDouble_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrVecDouble___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrVecDouble_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrVecDouble_swiginit(self, _cstl.new_MapStrVecDouble(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrVecDouble_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::vector< double > >::size_type":
        return _cstl.MapStrVecDouble_size(self)

    def swap(self, v: "MapStrVecDouble") -> "void":
        return _cstl.MapStrVecDouble_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::vector< double > >::iterator":
        return _cstl.MapStrVecDouble_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::vector< double > >::iterator":
        return _cstl.MapStrVecDouble_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrVecDouble_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::vector< double > >::allocator_type":
        return _cstl.MapStrVecDouble_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::vector< double > >::key_type const &") -> "std::unordered_map< std::string,std::vector< double > >::size_type":
        return _cstl.MapStrVecDouble_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrVecDouble_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::vector< double > >::key_type const &") -> "std::unordered_map< std::string,std::vector< double > >::iterator":
        return _cstl.MapStrVecDouble_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrVecDouble

# Register MapStrVecDouble in _cstl:
_cstl.MapStrVecDouble_swigregister(MapStrVecDouble)

class MapStrVecBool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrVecBool_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrVecBool___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrVecBool___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::vector< bool > >::size_type":
        return _cstl.MapStrVecBool___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::vector< bool > >::key_type const &") -> "std::unordered_map< std::string,std::vector< bool > >::mapped_type const &":
        return _cstl.MapStrVecBool___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::vector< bool > >::key_type const &") -> "void":
        return _cstl.MapStrVecBool___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::vector< bool > >::key_type const &") -> "bool":
        return _cstl.MapStrVecBool_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrVecBool_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrVecBool_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrVecBool_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::vector< bool > >::key_type const &") -> "bool":
        return _cstl.MapStrVecBool___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrVecBool_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrVecBool_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrVecBool___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrVecBool_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrVecBool_swiginit(self, _cstl.new_MapStrVecBool(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrVecBool_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::vector< bool > >::size_type":
        return _cstl.MapStrVecBool_size(self)

    def swap(self, v: "MapStrVecBool") -> "void":
        return _cstl.MapStrVecBool_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::vector< bool > >::iterator":
        return _cstl.MapStrVecBool_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::vector< bool > >::iterator":
        return _cstl.MapStrVecBool_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrVecBool_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::vector< bool > >::allocator_type":
        return _cstl.MapStrVecBool_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::vector< bool > >::key_type const &") -> "std::unordered_map< std::string,std::vector< bool > >::size_type":
        return _cstl.MapStrVecBool_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrVecBool_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::vector< bool > >::key_type const &") -> "std::unordered_map< std::string,std::vector< bool > >::iterator":
        return _cstl.MapStrVecBool_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrVecBool

# Register MapStrVecBool in _cstl:
_cstl.MapStrVecBool_swigregister(MapStrVecBool)

class MapStrVecLong(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrVecLong_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrVecLong___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrVecLong___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::vector< std::int64_t > >::size_type":
        return _cstl.MapStrVecLong___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::vector< std::int64_t > >::key_type const &") -> "std::unordered_map< std::string,std::vector< std::int64_t > >::mapped_type const &":
        return _cstl.MapStrVecLong___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::vector< std::int64_t > >::key_type const &") -> "void":
        return _cstl.MapStrVecLong___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::vector< std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapStrVecLong_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrVecLong_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrVecLong_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrVecLong_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::vector< std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapStrVecLong___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrVecLong_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrVecLong_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrVecLong___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrVecLong_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrVecLong_swiginit(self, _cstl.new_MapStrVecLong(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrVecLong_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::vector< std::int64_t > >::size_type":
        return _cstl.MapStrVecLong_size(self)

    def swap(self, v: "MapStrVecLong") -> "void":
        return _cstl.MapStrVecLong_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::vector< std::int64_t > >::iterator":
        return _cstl.MapStrVecLong_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::vector< std::int64_t > >::iterator":
        return _cstl.MapStrVecLong_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrVecLong_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::vector< std::int64_t > >::allocator_type":
        return _cstl.MapStrVecLong_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::vector< std::int64_t > >::key_type const &") -> "std::unordered_map< std::string,std::vector< std::int64_t > >::size_type":
        return _cstl.MapStrVecLong_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrVecLong_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::vector< std::int64_t > >::key_type const &") -> "std::unordered_map< std::string,std::vector< std::int64_t > >::iterator":
        return _cstl.MapStrVecLong_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrVecLong

# Register MapStrVecLong in _cstl:
_cstl.MapStrVecLong_swigregister(MapStrVecLong)

class MapStrSetInt(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrSetInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrSetInt___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrSetInt___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::unordered_set< int > >::size_type":
        return _cstl.MapStrSetInt___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::unordered_set< int > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_set< int > >::mapped_type const &":
        return _cstl.MapStrSetInt___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::unordered_set< int > >::key_type const &") -> "void":
        return _cstl.MapStrSetInt___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::unordered_set< int > >::key_type const &") -> "bool":
        return _cstl.MapStrSetInt_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrSetInt_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrSetInt_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrSetInt_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::unordered_set< int > >::key_type const &") -> "bool":
        return _cstl.MapStrSetInt___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrSetInt_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrSetInt_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrSetInt___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrSetInt_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrSetInt_swiginit(self, _cstl.new_MapStrSetInt(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrSetInt_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::unordered_set< int > >::size_type":
        return _cstl.MapStrSetInt_size(self)

    def swap(self, v: "MapStrSetInt") -> "void":
        return _cstl.MapStrSetInt_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::unordered_set< int > >::iterator":
        return _cstl.MapStrSetInt_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::unordered_set< int > >::iterator":
        return _cstl.MapStrSetInt_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrSetInt_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::unordered_set< int > >::allocator_type":
        return _cstl.MapStrSetInt_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::unordered_set< int > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_set< int > >::size_type":
        return _cstl.MapStrSetInt_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrSetInt_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::unordered_set< int > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_set< int > >::iterator":
        return _cstl.MapStrSetInt_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrSetInt

# Register MapStrSetInt in _cstl:
_cstl.MapStrSetInt_swigregister(MapStrSetInt)

class MapStrSetStr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrSetStr_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrSetStr___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrSetStr___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::unordered_set< std::string > >::size_type":
        return _cstl.MapStrSetStr___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::unordered_set< std::string > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_set< std::string > >::mapped_type const &":
        return _cstl.MapStrSetStr___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::unordered_set< std::string > >::key_type const &") -> "void":
        return _cstl.MapStrSetStr___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::unordered_set< std::string > >::key_type const &") -> "bool":
        return _cstl.MapStrSetStr_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrSetStr_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrSetStr_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrSetStr_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::unordered_set< std::string > >::key_type const &") -> "bool":
        return _cstl.MapStrSetStr___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrSetStr_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrSetStr_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrSetStr___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrSetStr_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrSetStr_swiginit(self, _cstl.new_MapStrSetStr(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrSetStr_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::unordered_set< std::string > >::size_type":
        return _cstl.MapStrSetStr_size(self)

    def swap(self, v: "MapStrSetStr") -> "void":
        return _cstl.MapStrSetStr_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::unordered_set< std::string > >::iterator":
        return _cstl.MapStrSetStr_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::unordered_set< std::string > >::iterator":
        return _cstl.MapStrSetStr_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrSetStr_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::unordered_set< std::string > >::allocator_type":
        return _cstl.MapStrSetStr_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::unordered_set< std::string > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_set< std::string > >::size_type":
        return _cstl.MapStrSetStr_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrSetStr_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::unordered_set< std::string > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_set< std::string > >::iterator":
        return _cstl.MapStrSetStr_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrSetStr

# Register MapStrSetStr in _cstl:
_cstl.MapStrSetStr_swigregister(MapStrSetStr)

class MapStrSetLong(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrSetLong_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrSetLong___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrSetLong___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::unordered_set< std::int64_t > >::size_type":
        return _cstl.MapStrSetLong___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::unordered_set< std::int64_t > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_set< std::int64_t > >::mapped_type const &":
        return _cstl.MapStrSetLong___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::unordered_set< std::int64_t > >::key_type const &") -> "void":
        return _cstl.MapStrSetLong___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::unordered_set< std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapStrSetLong_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrSetLong_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrSetLong_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrSetLong_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::unordered_set< std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapStrSetLong___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrSetLong_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrSetLong_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrSetLong___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrSetLong_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrSetLong_swiginit(self, _cstl.new_MapStrSetLong(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrSetLong_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::unordered_set< std::int64_t > >::size_type":
        return _cstl.MapStrSetLong_size(self)

    def swap(self, v: "MapStrSetLong") -> "void":
        return _cstl.MapStrSetLong_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::unordered_set< std::int64_t > >::iterator":
        return _cstl.MapStrSetLong_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::unordered_set< std::int64_t > >::iterator":
        return _cstl.MapStrSetLong_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrSetLong_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::unordered_set< std::int64_t > >::allocator_type":
        return _cstl.MapStrSetLong_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::unordered_set< std::int64_t > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_set< std::int64_t > >::size_type":
        return _cstl.MapStrSetLong_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrSetLong_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::unordered_set< std::int64_t > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_set< std::int64_t > >::iterator":
        return _cstl.MapStrSetLong_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrSetLong

# Register MapStrSetLong in _cstl:
_cstl.MapStrSetLong_swigregister(MapStrSetLong)

class MapStrMapIntInt(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapIntInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrMapIntInt___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrMapIntInt___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::unordered_map< int,int > >::size_type":
        return _cstl.MapStrMapIntInt___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::unordered_map< int,int > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< int,int > >::mapped_type const &":
        return _cstl.MapStrMapIntInt___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::unordered_map< int,int > >::key_type const &") -> "void":
        return _cstl.MapStrMapIntInt___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::unordered_map< int,int > >::key_type const &") -> "bool":
        return _cstl.MapStrMapIntInt_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrMapIntInt_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrMapIntInt_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrMapIntInt_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::unordered_map< int,int > >::key_type const &") -> "bool":
        return _cstl.MapStrMapIntInt___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapIntInt_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapIntInt_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrMapIntInt___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrMapIntInt_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrMapIntInt_swiginit(self, _cstl.new_MapStrMapIntInt(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrMapIntInt_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::unordered_map< int,int > >::size_type":
        return _cstl.MapStrMapIntInt_size(self)

    def swap(self, v: "MapStrMapIntInt") -> "void":
        return _cstl.MapStrMapIntInt_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::unordered_map< int,int > >::iterator":
        return _cstl.MapStrMapIntInt_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::unordered_map< int,int > >::iterator":
        return _cstl.MapStrMapIntInt_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrMapIntInt_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::unordered_map< int,int > >::allocator_type":
        return _cstl.MapStrMapIntInt_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::unordered_map< int,int > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< int,int > >::size_type":
        return _cstl.MapStrMapIntInt_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrMapIntInt_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::unordered_map< int,int > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< int,int > >::iterator":
        return _cstl.MapStrMapIntInt_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrMapIntInt

# Register MapStrMapIntInt in _cstl:
_cstl.MapStrMapIntInt_swigregister(MapStrMapIntInt)

class MapStrMapIntStr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapIntStr_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrMapIntStr___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrMapIntStr___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::unordered_map< int,std::string > >::size_type":
        return _cstl.MapStrMapIntStr___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::unordered_map< int,std::string > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< int,std::string > >::mapped_type const &":
        return _cstl.MapStrMapIntStr___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::unordered_map< int,std::string > >::key_type const &") -> "void":
        return _cstl.MapStrMapIntStr___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::unordered_map< int,std::string > >::key_type const &") -> "bool":
        return _cstl.MapStrMapIntStr_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrMapIntStr_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrMapIntStr_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrMapIntStr_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::unordered_map< int,std::string > >::key_type const &") -> "bool":
        return _cstl.MapStrMapIntStr___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapIntStr_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapIntStr_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrMapIntStr___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrMapIntStr_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrMapIntStr_swiginit(self, _cstl.new_MapStrMapIntStr(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrMapIntStr_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::unordered_map< int,std::string > >::size_type":
        return _cstl.MapStrMapIntStr_size(self)

    def swap(self, v: "MapStrMapIntStr") -> "void":
        return _cstl.MapStrMapIntStr_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::unordered_map< int,std::string > >::iterator":
        return _cstl.MapStrMapIntStr_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::unordered_map< int,std::string > >::iterator":
        return _cstl.MapStrMapIntStr_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrMapIntStr_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::unordered_map< int,std::string > >::allocator_type":
        return _cstl.MapStrMapIntStr_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::unordered_map< int,std::string > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< int,std::string > >::size_type":
        return _cstl.MapStrMapIntStr_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrMapIntStr_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::unordered_map< int,std::string > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< int,std::string > >::iterator":
        return _cstl.MapStrMapIntStr_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrMapIntStr

# Register MapStrMapIntStr in _cstl:
_cstl.MapStrMapIntStr_swigregister(MapStrMapIntStr)

class MapStrMapIntFloat(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapIntFloat_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrMapIntFloat___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrMapIntFloat___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::unordered_map< int,float > >::size_type":
        return _cstl.MapStrMapIntFloat___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::unordered_map< int,float > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< int,float > >::mapped_type const &":
        return _cstl.MapStrMapIntFloat___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::unordered_map< int,float > >::key_type const &") -> "void":
        return _cstl.MapStrMapIntFloat___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::unordered_map< int,float > >::key_type const &") -> "bool":
        return _cstl.MapStrMapIntFloat_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrMapIntFloat_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrMapIntFloat_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrMapIntFloat_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::unordered_map< int,float > >::key_type const &") -> "bool":
        return _cstl.MapStrMapIntFloat___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapIntFloat_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapIntFloat_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrMapIntFloat___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrMapIntFloat_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrMapIntFloat_swiginit(self, _cstl.new_MapStrMapIntFloat(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrMapIntFloat_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::unordered_map< int,float > >::size_type":
        return _cstl.MapStrMapIntFloat_size(self)

    def swap(self, v: "MapStrMapIntFloat") -> "void":
        return _cstl.MapStrMapIntFloat_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::unordered_map< int,float > >::iterator":
        return _cstl.MapStrMapIntFloat_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::unordered_map< int,float > >::iterator":
        return _cstl.MapStrMapIntFloat_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrMapIntFloat_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::unordered_map< int,float > >::allocator_type":
        return _cstl.MapStrMapIntFloat_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::unordered_map< int,float > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< int,float > >::size_type":
        return _cstl.MapStrMapIntFloat_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrMapIntFloat_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::unordered_map< int,float > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< int,float > >::iterator":
        return _cstl.MapStrMapIntFloat_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrMapIntFloat

# Register MapStrMapIntFloat in _cstl:
_cstl.MapStrMapIntFloat_swigregister(MapStrMapIntFloat)

class MapStrMapIntDouble(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapIntDouble_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrMapIntDouble___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrMapIntDouble___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::unordered_map< int,double > >::size_type":
        return _cstl.MapStrMapIntDouble___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::unordered_map< int,double > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< int,double > >::mapped_type const &":
        return _cstl.MapStrMapIntDouble___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::unordered_map< int,double > >::key_type const &") -> "void":
        return _cstl.MapStrMapIntDouble___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::unordered_map< int,double > >::key_type const &") -> "bool":
        return _cstl.MapStrMapIntDouble_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrMapIntDouble_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrMapIntDouble_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrMapIntDouble_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::unordered_map< int,double > >::key_type const &") -> "bool":
        return _cstl.MapStrMapIntDouble___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapIntDouble_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapIntDouble_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrMapIntDouble___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrMapIntDouble_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrMapIntDouble_swiginit(self, _cstl.new_MapStrMapIntDouble(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrMapIntDouble_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::unordered_map< int,double > >::size_type":
        return _cstl.MapStrMapIntDouble_size(self)

    def swap(self, v: "MapStrMapIntDouble") -> "void":
        return _cstl.MapStrMapIntDouble_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::unordered_map< int,double > >::iterator":
        return _cstl.MapStrMapIntDouble_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::unordered_map< int,double > >::iterator":
        return _cstl.MapStrMapIntDouble_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrMapIntDouble_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::unordered_map< int,double > >::allocator_type":
        return _cstl.MapStrMapIntDouble_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::unordered_map< int,double > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< int,double > >::size_type":
        return _cstl.MapStrMapIntDouble_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrMapIntDouble_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::unordered_map< int,double > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< int,double > >::iterator":
        return _cstl.MapStrMapIntDouble_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrMapIntDouble

# Register MapStrMapIntDouble in _cstl:
_cstl.MapStrMapIntDouble_swigregister(MapStrMapIntDouble)

class MapStrMapIntBool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapIntBool_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrMapIntBool___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrMapIntBool___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::unordered_map< int,bool > >::size_type":
        return _cstl.MapStrMapIntBool___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::unordered_map< int,bool > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< int,bool > >::mapped_type const &":
        return _cstl.MapStrMapIntBool___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::unordered_map< int,bool > >::key_type const &") -> "void":
        return _cstl.MapStrMapIntBool___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::unordered_map< int,bool > >::key_type const &") -> "bool":
        return _cstl.MapStrMapIntBool_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrMapIntBool_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrMapIntBool_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrMapIntBool_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::unordered_map< int,bool > >::key_type const &") -> "bool":
        return _cstl.MapStrMapIntBool___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapIntBool_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapIntBool_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrMapIntBool___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrMapIntBool_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrMapIntBool_swiginit(self, _cstl.new_MapStrMapIntBool(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrMapIntBool_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::unordered_map< int,bool > >::size_type":
        return _cstl.MapStrMapIntBool_size(self)

    def swap(self, v: "MapStrMapIntBool") -> "void":
        return _cstl.MapStrMapIntBool_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::unordered_map< int,bool > >::iterator":
        return _cstl.MapStrMapIntBool_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::unordered_map< int,bool > >::iterator":
        return _cstl.MapStrMapIntBool_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrMapIntBool_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::unordered_map< int,bool > >::allocator_type":
        return _cstl.MapStrMapIntBool_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::unordered_map< int,bool > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< int,bool > >::size_type":
        return _cstl.MapStrMapIntBool_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrMapIntBool_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::unordered_map< int,bool > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< int,bool > >::iterator":
        return _cstl.MapStrMapIntBool_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrMapIntBool

# Register MapStrMapIntBool in _cstl:
_cstl.MapStrMapIntBool_swigregister(MapStrMapIntBool)

class MapStrMapIntLong(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapIntLong_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrMapIntLong___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrMapIntLong___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::unordered_map< int,std::int64_t > >::size_type":
        return _cstl.MapStrMapIntLong___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::unordered_map< int,std::int64_t > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< int,std::int64_t > >::mapped_type const &":
        return _cstl.MapStrMapIntLong___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::unordered_map< int,std::int64_t > >::key_type const &") -> "void":
        return _cstl.MapStrMapIntLong___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::unordered_map< int,std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapStrMapIntLong_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrMapIntLong_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrMapIntLong_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrMapIntLong_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::unordered_map< int,std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapStrMapIntLong___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapIntLong_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapIntLong_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrMapIntLong___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrMapIntLong_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrMapIntLong_swiginit(self, _cstl.new_MapStrMapIntLong(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrMapIntLong_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::unordered_map< int,std::int64_t > >::size_type":
        return _cstl.MapStrMapIntLong_size(self)

    def swap(self, v: "MapStrMapIntLong") -> "void":
        return _cstl.MapStrMapIntLong_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::unordered_map< int,std::int64_t > >::iterator":
        return _cstl.MapStrMapIntLong_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::unordered_map< int,std::int64_t > >::iterator":
        return _cstl.MapStrMapIntLong_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrMapIntLong_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::unordered_map< int,std::int64_t > >::allocator_type":
        return _cstl.MapStrMapIntLong_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::unordered_map< int,std::int64_t > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< int,std::int64_t > >::size_type":
        return _cstl.MapStrMapIntLong_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrMapIntLong_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::unordered_map< int,std::int64_t > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< int,std::int64_t > >::iterator":
        return _cstl.MapStrMapIntLong_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrMapIntLong

# Register MapStrMapIntLong in _cstl:
_cstl.MapStrMapIntLong_swigregister(MapStrMapIntLong)

class MapStrMapStrInt(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapStrInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrMapStrInt___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrMapStrInt___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,int > >::size_type":
        return _cstl.MapStrMapStrInt___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::unordered_map< std::string,int > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::string,int > >::mapped_type const &":
        return _cstl.MapStrMapStrInt___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::unordered_map< std::string,int > >::key_type const &") -> "void":
        return _cstl.MapStrMapStrInt___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::unordered_map< std::string,int > >::key_type const &") -> "bool":
        return _cstl.MapStrMapStrInt_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrMapStrInt_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrMapStrInt_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrMapStrInt_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::unordered_map< std::string,int > >::key_type const &") -> "bool":
        return _cstl.MapStrMapStrInt___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapStrInt_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapStrInt_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrMapStrInt___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrMapStrInt_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrMapStrInt_swiginit(self, _cstl.new_MapStrMapStrInt(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrMapStrInt_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,int > >::size_type":
        return _cstl.MapStrMapStrInt_size(self)

    def swap(self, v: "MapStrMapStrInt") -> "void":
        return _cstl.MapStrMapStrInt_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,int > >::iterator":
        return _cstl.MapStrMapStrInt_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,int > >::iterator":
        return _cstl.MapStrMapStrInt_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrMapStrInt_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,int > >::allocator_type":
        return _cstl.MapStrMapStrInt_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::unordered_map< std::string,int > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::string,int > >::size_type":
        return _cstl.MapStrMapStrInt_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrMapStrInt_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::unordered_map< std::string,int > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::string,int > >::iterator":
        return _cstl.MapStrMapStrInt_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrMapStrInt

# Register MapStrMapStrInt in _cstl:
_cstl.MapStrMapStrInt_swigregister(MapStrMapStrInt)

class MapStrMapStrStr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapStrStr_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrMapStrStr___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrMapStrStr___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,std::string > >::size_type":
        return _cstl.MapStrMapStrStr___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::unordered_map< std::string,std::string > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::string,std::string > >::mapped_type const &":
        return _cstl.MapStrMapStrStr___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::unordered_map< std::string,std::string > >::key_type const &") -> "void":
        return _cstl.MapStrMapStrStr___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::unordered_map< std::string,std::string > >::key_type const &") -> "bool":
        return _cstl.MapStrMapStrStr_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrMapStrStr_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrMapStrStr_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrMapStrStr_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::unordered_map< std::string,std::string > >::key_type const &") -> "bool":
        return _cstl.MapStrMapStrStr___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapStrStr_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapStrStr_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrMapStrStr___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrMapStrStr_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrMapStrStr_swiginit(self, _cstl.new_MapStrMapStrStr(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrMapStrStr_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,std::string > >::size_type":
        return _cstl.MapStrMapStrStr_size(self)

    def swap(self, v: "MapStrMapStrStr") -> "void":
        return _cstl.MapStrMapStrStr_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,std::string > >::iterator":
        return _cstl.MapStrMapStrStr_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,std::string > >::iterator":
        return _cstl.MapStrMapStrStr_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrMapStrStr_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,std::string > >::allocator_type":
        return _cstl.MapStrMapStrStr_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::unordered_map< std::string,std::string > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::string,std::string > >::size_type":
        return _cstl.MapStrMapStrStr_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrMapStrStr_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::unordered_map< std::string,std::string > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::string,std::string > >::iterator":
        return _cstl.MapStrMapStrStr_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrMapStrStr

# Register MapStrMapStrStr in _cstl:
_cstl.MapStrMapStrStr_swigregister(MapStrMapStrStr)

class MapStrMapStrFloat(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapStrFloat_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrMapStrFloat___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrMapStrFloat___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,float > >::size_type":
        return _cstl.MapStrMapStrFloat___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::unordered_map< std::string,float > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::string,float > >::mapped_type const &":
        return _cstl.MapStrMapStrFloat___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::unordered_map< std::string,float > >::key_type const &") -> "void":
        return _cstl.MapStrMapStrFloat___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::unordered_map< std::string,float > >::key_type const &") -> "bool":
        return _cstl.MapStrMapStrFloat_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrMapStrFloat_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrMapStrFloat_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrMapStrFloat_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::unordered_map< std::string,float > >::key_type const &") -> "bool":
        return _cstl.MapStrMapStrFloat___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapStrFloat_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapStrFloat_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrMapStrFloat___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrMapStrFloat_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrMapStrFloat_swiginit(self, _cstl.new_MapStrMapStrFloat(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrMapStrFloat_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,float > >::size_type":
        return _cstl.MapStrMapStrFloat_size(self)

    def swap(self, v: "MapStrMapStrFloat") -> "void":
        return _cstl.MapStrMapStrFloat_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,float > >::iterator":
        return _cstl.MapStrMapStrFloat_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,float > >::iterator":
        return _cstl.MapStrMapStrFloat_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrMapStrFloat_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,float > >::allocator_type":
        return _cstl.MapStrMapStrFloat_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::unordered_map< std::string,float > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::string,float > >::size_type":
        return _cstl.MapStrMapStrFloat_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrMapStrFloat_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::unordered_map< std::string,float > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::string,float > >::iterator":
        return _cstl.MapStrMapStrFloat_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrMapStrFloat

# Register MapStrMapStrFloat in _cstl:
_cstl.MapStrMapStrFloat_swigregister(MapStrMapStrFloat)

class MapStrMapStrDouble(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapStrDouble_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrMapStrDouble___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrMapStrDouble___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,double > >::size_type":
        return _cstl.MapStrMapStrDouble___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::unordered_map< std::string,double > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::string,double > >::mapped_type const &":
        return _cstl.MapStrMapStrDouble___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::unordered_map< std::string,double > >::key_type const &") -> "void":
        return _cstl.MapStrMapStrDouble___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::unordered_map< std::string,double > >::key_type const &") -> "bool":
        return _cstl.MapStrMapStrDouble_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrMapStrDouble_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrMapStrDouble_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrMapStrDouble_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::unordered_map< std::string,double > >::key_type const &") -> "bool":
        return _cstl.MapStrMapStrDouble___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapStrDouble_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapStrDouble_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrMapStrDouble___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrMapStrDouble_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrMapStrDouble_swiginit(self, _cstl.new_MapStrMapStrDouble(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrMapStrDouble_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,double > >::size_type":
        return _cstl.MapStrMapStrDouble_size(self)

    def swap(self, v: "MapStrMapStrDouble") -> "void":
        return _cstl.MapStrMapStrDouble_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,double > >::iterator":
        return _cstl.MapStrMapStrDouble_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,double > >::iterator":
        return _cstl.MapStrMapStrDouble_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrMapStrDouble_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,double > >::allocator_type":
        return _cstl.MapStrMapStrDouble_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::unordered_map< std::string,double > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::string,double > >::size_type":
        return _cstl.MapStrMapStrDouble_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrMapStrDouble_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::unordered_map< std::string,double > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::string,double > >::iterator":
        return _cstl.MapStrMapStrDouble_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrMapStrDouble

# Register MapStrMapStrDouble in _cstl:
_cstl.MapStrMapStrDouble_swigregister(MapStrMapStrDouble)

class MapStrMapStrBool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapStrBool_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrMapStrBool___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrMapStrBool___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,bool > >::size_type":
        return _cstl.MapStrMapStrBool___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::unordered_map< std::string,bool > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::string,bool > >::mapped_type const &":
        return _cstl.MapStrMapStrBool___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::unordered_map< std::string,bool > >::key_type const &") -> "void":
        return _cstl.MapStrMapStrBool___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::unordered_map< std::string,bool > >::key_type const &") -> "bool":
        return _cstl.MapStrMapStrBool_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrMapStrBool_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrMapStrBool_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrMapStrBool_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::unordered_map< std::string,bool > >::key_type const &") -> "bool":
        return _cstl.MapStrMapStrBool___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapStrBool_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapStrBool_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrMapStrBool___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrMapStrBool_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrMapStrBool_swiginit(self, _cstl.new_MapStrMapStrBool(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrMapStrBool_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,bool > >::size_type":
        return _cstl.MapStrMapStrBool_size(self)

    def swap(self, v: "MapStrMapStrBool") -> "void":
        return _cstl.MapStrMapStrBool_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,bool > >::iterator":
        return _cstl.MapStrMapStrBool_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,bool > >::iterator":
        return _cstl.MapStrMapStrBool_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrMapStrBool_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,bool > >::allocator_type":
        return _cstl.MapStrMapStrBool_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::unordered_map< std::string,bool > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::string,bool > >::size_type":
        return _cstl.MapStrMapStrBool_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrMapStrBool_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::unordered_map< std::string,bool > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::string,bool > >::iterator":
        return _cstl.MapStrMapStrBool_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrMapStrBool

# Register MapStrMapStrBool in _cstl:
_cstl.MapStrMapStrBool_swigregister(MapStrMapStrBool)

class MapStrMapStrLong(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapStrLong_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrMapStrLong___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrMapStrLong___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,std::int64_t > >::size_type":
        return _cstl.MapStrMapStrLong___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::unordered_map< std::string,std::int64_t > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::string,std::int64_t > >::mapped_type const &":
        return _cstl.MapStrMapStrLong___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::unordered_map< std::string,std::int64_t > >::key_type const &") -> "void":
        return _cstl.MapStrMapStrLong___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::unordered_map< std::string,std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapStrMapStrLong_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrMapStrLong_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrMapStrLong_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrMapStrLong_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::unordered_map< std::string,std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapStrMapStrLong___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapStrLong_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapStrLong_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrMapStrLong___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrMapStrLong_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrMapStrLong_swiginit(self, _cstl.new_MapStrMapStrLong(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrMapStrLong_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,std::int64_t > >::size_type":
        return _cstl.MapStrMapStrLong_size(self)

    def swap(self, v: "MapStrMapStrLong") -> "void":
        return _cstl.MapStrMapStrLong_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,std::int64_t > >::iterator":
        return _cstl.MapStrMapStrLong_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,std::int64_t > >::iterator":
        return _cstl.MapStrMapStrLong_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrMapStrLong_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::unordered_map< std::string,std::int64_t > >::allocator_type":
        return _cstl.MapStrMapStrLong_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::unordered_map< std::string,std::int64_t > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::string,std::int64_t > >::size_type":
        return _cstl.MapStrMapStrLong_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrMapStrLong_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::unordered_map< std::string,std::int64_t > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::string,std::int64_t > >::iterator":
        return _cstl.MapStrMapStrLong_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrMapStrLong

# Register MapStrMapStrLong in _cstl:
_cstl.MapStrMapStrLong_swigregister(MapStrMapStrLong)

class MapStrMapLongInt(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapLongInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrMapLongInt___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrMapLongInt___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,int > >::size_type":
        return _cstl.MapStrMapLongInt___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::unordered_map< std::int64_t,int > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,int > >::mapped_type const &":
        return _cstl.MapStrMapLongInt___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::unordered_map< std::int64_t,int > >::key_type const &") -> "void":
        return _cstl.MapStrMapLongInt___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::unordered_map< std::int64_t,int > >::key_type const &") -> "bool":
        return _cstl.MapStrMapLongInt_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrMapLongInt_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrMapLongInt_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrMapLongInt_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::unordered_map< std::int64_t,int > >::key_type const &") -> "bool":
        return _cstl.MapStrMapLongInt___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapLongInt_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapLongInt_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrMapLongInt___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrMapLongInt_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrMapLongInt_swiginit(self, _cstl.new_MapStrMapLongInt(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrMapLongInt_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,int > >::size_type":
        return _cstl.MapStrMapLongInt_size(self)

    def swap(self, v: "MapStrMapLongInt") -> "void":
        return _cstl.MapStrMapLongInt_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,int > >::iterator":
        return _cstl.MapStrMapLongInt_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,int > >::iterator":
        return _cstl.MapStrMapLongInt_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrMapLongInt_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,int > >::allocator_type":
        return _cstl.MapStrMapLongInt_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::unordered_map< std::int64_t,int > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,int > >::size_type":
        return _cstl.MapStrMapLongInt_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrMapLongInt_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::unordered_map< std::int64_t,int > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,int > >::iterator":
        return _cstl.MapStrMapLongInt_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrMapLongInt

# Register MapStrMapLongInt in _cstl:
_cstl.MapStrMapLongInt_swigregister(MapStrMapLongInt)

class MapStrMapLongStr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapLongStr_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrMapLongStr___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrMapLongStr___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,std::string > >::size_type":
        return _cstl.MapStrMapLongStr___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::unordered_map< std::int64_t,std::string > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,std::string > >::mapped_type const &":
        return _cstl.MapStrMapLongStr___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::unordered_map< std::int64_t,std::string > >::key_type const &") -> "void":
        return _cstl.MapStrMapLongStr___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::unordered_map< std::int64_t,std::string > >::key_type const &") -> "bool":
        return _cstl.MapStrMapLongStr_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrMapLongStr_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrMapLongStr_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrMapLongStr_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::unordered_map< std::int64_t,std::string > >::key_type const &") -> "bool":
        return _cstl.MapStrMapLongStr___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapLongStr_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapLongStr_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrMapLongStr___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrMapLongStr_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrMapLongStr_swiginit(self, _cstl.new_MapStrMapLongStr(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrMapLongStr_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,std::string > >::size_type":
        return _cstl.MapStrMapLongStr_size(self)

    def swap(self, v: "MapStrMapLongStr") -> "void":
        return _cstl.MapStrMapLongStr_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,std::string > >::iterator":
        return _cstl.MapStrMapLongStr_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,std::string > >::iterator":
        return _cstl.MapStrMapLongStr_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrMapLongStr_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,std::string > >::allocator_type":
        return _cstl.MapStrMapLongStr_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::unordered_map< std::int64_t,std::string > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,std::string > >::size_type":
        return _cstl.MapStrMapLongStr_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrMapLongStr_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::unordered_map< std::int64_t,std::string > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,std::string > >::iterator":
        return _cstl.MapStrMapLongStr_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrMapLongStr

# Register MapStrMapLongStr in _cstl:
_cstl.MapStrMapLongStr_swigregister(MapStrMapLongStr)

class MapStrMapLongFloat(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapLongFloat_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrMapLongFloat___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrMapLongFloat___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,float > >::size_type":
        return _cstl.MapStrMapLongFloat___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::unordered_map< std::int64_t,float > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,float > >::mapped_type const &":
        return _cstl.MapStrMapLongFloat___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::unordered_map< std::int64_t,float > >::key_type const &") -> "void":
        return _cstl.MapStrMapLongFloat___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::unordered_map< std::int64_t,float > >::key_type const &") -> "bool":
        return _cstl.MapStrMapLongFloat_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrMapLongFloat_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrMapLongFloat_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrMapLongFloat_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::unordered_map< std::int64_t,float > >::key_type const &") -> "bool":
        return _cstl.MapStrMapLongFloat___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapLongFloat_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapLongFloat_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrMapLongFloat___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrMapLongFloat_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrMapLongFloat_swiginit(self, _cstl.new_MapStrMapLongFloat(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrMapLongFloat_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,float > >::size_type":
        return _cstl.MapStrMapLongFloat_size(self)

    def swap(self, v: "MapStrMapLongFloat") -> "void":
        return _cstl.MapStrMapLongFloat_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,float > >::iterator":
        return _cstl.MapStrMapLongFloat_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,float > >::iterator":
        return _cstl.MapStrMapLongFloat_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrMapLongFloat_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,float > >::allocator_type":
        return _cstl.MapStrMapLongFloat_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::unordered_map< std::int64_t,float > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,float > >::size_type":
        return _cstl.MapStrMapLongFloat_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrMapLongFloat_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::unordered_map< std::int64_t,float > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,float > >::iterator":
        return _cstl.MapStrMapLongFloat_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrMapLongFloat

# Register MapStrMapLongFloat in _cstl:
_cstl.MapStrMapLongFloat_swigregister(MapStrMapLongFloat)

class MapStrMapLongDouble(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapLongDouble_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrMapLongDouble___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrMapLongDouble___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,double > >::size_type":
        return _cstl.MapStrMapLongDouble___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::unordered_map< std::int64_t,double > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,double > >::mapped_type const &":
        return _cstl.MapStrMapLongDouble___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::unordered_map< std::int64_t,double > >::key_type const &") -> "void":
        return _cstl.MapStrMapLongDouble___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::unordered_map< std::int64_t,double > >::key_type const &") -> "bool":
        return _cstl.MapStrMapLongDouble_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrMapLongDouble_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrMapLongDouble_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrMapLongDouble_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::unordered_map< std::int64_t,double > >::key_type const &") -> "bool":
        return _cstl.MapStrMapLongDouble___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapLongDouble_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapLongDouble_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrMapLongDouble___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrMapLongDouble_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrMapLongDouble_swiginit(self, _cstl.new_MapStrMapLongDouble(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrMapLongDouble_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,double > >::size_type":
        return _cstl.MapStrMapLongDouble_size(self)

    def swap(self, v: "MapStrMapLongDouble") -> "void":
        return _cstl.MapStrMapLongDouble_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,double > >::iterator":
        return _cstl.MapStrMapLongDouble_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,double > >::iterator":
        return _cstl.MapStrMapLongDouble_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrMapLongDouble_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,double > >::allocator_type":
        return _cstl.MapStrMapLongDouble_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::unordered_map< std::int64_t,double > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,double > >::size_type":
        return _cstl.MapStrMapLongDouble_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrMapLongDouble_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::unordered_map< std::int64_t,double > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,double > >::iterator":
        return _cstl.MapStrMapLongDouble_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrMapLongDouble

# Register MapStrMapLongDouble in _cstl:
_cstl.MapStrMapLongDouble_swigregister(MapStrMapLongDouble)

class MapStrMapLongBool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapLongBool_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrMapLongBool___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrMapLongBool___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,bool > >::size_type":
        return _cstl.MapStrMapLongBool___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::unordered_map< std::int64_t,bool > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,bool > >::mapped_type const &":
        return _cstl.MapStrMapLongBool___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::unordered_map< std::int64_t,bool > >::key_type const &") -> "void":
        return _cstl.MapStrMapLongBool___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::unordered_map< std::int64_t,bool > >::key_type const &") -> "bool":
        return _cstl.MapStrMapLongBool_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrMapLongBool_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrMapLongBool_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrMapLongBool_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::unordered_map< std::int64_t,bool > >::key_type const &") -> "bool":
        return _cstl.MapStrMapLongBool___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapLongBool_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapLongBool_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrMapLongBool___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrMapLongBool_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrMapLongBool_swiginit(self, _cstl.new_MapStrMapLongBool(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrMapLongBool_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,bool > >::size_type":
        return _cstl.MapStrMapLongBool_size(self)

    def swap(self, v: "MapStrMapLongBool") -> "void":
        return _cstl.MapStrMapLongBool_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,bool > >::iterator":
        return _cstl.MapStrMapLongBool_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,bool > >::iterator":
        return _cstl.MapStrMapLongBool_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrMapLongBool_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,bool > >::allocator_type":
        return _cstl.MapStrMapLongBool_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::unordered_map< std::int64_t,bool > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,bool > >::size_type":
        return _cstl.MapStrMapLongBool_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrMapLongBool_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::unordered_map< std::int64_t,bool > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,bool > >::iterator":
        return _cstl.MapStrMapLongBool_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrMapLongBool

# Register MapStrMapLongBool in _cstl:
_cstl.MapStrMapLongBool_swigregister(MapStrMapLongBool)

class MapStrMapLongLong(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapLongLong_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapStrMapLongLong___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapStrMapLongLong___bool__(self)

    def __len__(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,std::int64_t > >::size_type":
        return _cstl.MapStrMapLongLong___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::string,std::unordered_map< std::int64_t,std::int64_t > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,std::int64_t > >::mapped_type const &":
        return _cstl.MapStrMapLongLong___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::string,std::unordered_map< std::int64_t,std::int64_t > >::key_type const &") -> "void":
        return _cstl.MapStrMapLongLong___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::string,std::unordered_map< std::int64_t,std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapStrMapLongLong_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapStrMapLongLong_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapStrMapLongLong_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapStrMapLongLong_items(self)

    def __contains__(self, key: "std::unordered_map< std::string,std::unordered_map< std::int64_t,std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapStrMapLongLong___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapLongLong_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapStrMapLongLong_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapStrMapLongLong___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapStrMapLongLong_asdict(self)

    def __init__(self, *args):
        _cstl.MapStrMapLongLong_swiginit(self, _cstl.new_MapStrMapLongLong(*args))

    def empty(self) -> "bool":
        return _cstl.MapStrMapLongLong_empty(self)

    def size(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,std::int64_t > >::size_type":
        return _cstl.MapStrMapLongLong_size(self)

    def swap(self, v: "MapStrMapLongLong") -> "void":
        return _cstl.MapStrMapLongLong_swap(self, v)

    def begin(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,std::int64_t > >::iterator":
        return _cstl.MapStrMapLongLong_begin(self)

    def end(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,std::int64_t > >::iterator":
        return _cstl.MapStrMapLongLong_end(self)

    def clear(self) -> "void":
        return _cstl.MapStrMapLongLong_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,std::int64_t > >::allocator_type":
        return _cstl.MapStrMapLongLong_get_allocator(self)

    def count(self, x: "std::unordered_map< std::string,std::unordered_map< std::int64_t,std::int64_t > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,std::int64_t > >::size_type":
        return _cstl.MapStrMapLongLong_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapStrMapLongLong_erase(self, *args)

    def find(self, x: "std::unordered_map< std::string,std::unordered_map< std::int64_t,std::int64_t > >::key_type const &") -> "std::unordered_map< std::string,std::unordered_map< std::int64_t,std::int64_t > >::iterator":
        return _cstl.MapStrMapLongLong_find(self, x)
    __swig_destroy__ = _cstl.delete_MapStrMapLongLong

# Register MapStrMapLongLong in _cstl:
_cstl.MapStrMapLongLong_swigregister(MapStrMapLongLong)

class MapLongVecInt(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongVecInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongVecInt___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongVecInt___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::vector< int > >::size_type":
        return _cstl.MapLongVecInt___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::vector< int > >::key_type const &") -> "std::unordered_map< std::int64_t,std::vector< int > >::mapped_type const &":
        return _cstl.MapLongVecInt___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::vector< int > >::key_type const &") -> "void":
        return _cstl.MapLongVecInt___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::vector< int > >::key_type const &") -> "bool":
        return _cstl.MapLongVecInt_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongVecInt_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongVecInt_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongVecInt_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::vector< int > >::key_type const &") -> "bool":
        return _cstl.MapLongVecInt___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongVecInt_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongVecInt_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongVecInt___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongVecInt_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongVecInt_swiginit(self, _cstl.new_MapLongVecInt(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongVecInt_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::vector< int > >::size_type":
        return _cstl.MapLongVecInt_size(self)

    def swap(self, v: "MapLongVecInt") -> "void":
        return _cstl.MapLongVecInt_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::vector< int > >::iterator":
        return _cstl.MapLongVecInt_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::vector< int > >::iterator":
        return _cstl.MapLongVecInt_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongVecInt_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::vector< int > >::allocator_type":
        return _cstl.MapLongVecInt_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::vector< int > >::key_type const &") -> "std::unordered_map< std::int64_t,std::vector< int > >::size_type":
        return _cstl.MapLongVecInt_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongVecInt_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::vector< int > >::key_type const &") -> "std::unordered_map< std::int64_t,std::vector< int > >::iterator":
        return _cstl.MapLongVecInt_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongVecInt

# Register MapLongVecInt in _cstl:
_cstl.MapLongVecInt_swigregister(MapLongVecInt)

class MapLongVecStr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongVecStr_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongVecStr___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongVecStr___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::vector< std::string > >::size_type":
        return _cstl.MapLongVecStr___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::vector< std::string > >::key_type const &") -> "std::unordered_map< std::int64_t,std::vector< std::string > >::mapped_type const &":
        return _cstl.MapLongVecStr___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::vector< std::string > >::key_type const &") -> "void":
        return _cstl.MapLongVecStr___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::vector< std::string > >::key_type const &") -> "bool":
        return _cstl.MapLongVecStr_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongVecStr_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongVecStr_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongVecStr_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::vector< std::string > >::key_type const &") -> "bool":
        return _cstl.MapLongVecStr___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongVecStr_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongVecStr_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongVecStr___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongVecStr_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongVecStr_swiginit(self, _cstl.new_MapLongVecStr(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongVecStr_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::vector< std::string > >::size_type":
        return _cstl.MapLongVecStr_size(self)

    def swap(self, v: "MapLongVecStr") -> "void":
        return _cstl.MapLongVecStr_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::vector< std::string > >::iterator":
        return _cstl.MapLongVecStr_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::vector< std::string > >::iterator":
        return _cstl.MapLongVecStr_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongVecStr_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::vector< std::string > >::allocator_type":
        return _cstl.MapLongVecStr_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::vector< std::string > >::key_type const &") -> "std::unordered_map< std::int64_t,std::vector< std::string > >::size_type":
        return _cstl.MapLongVecStr_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongVecStr_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::vector< std::string > >::key_type const &") -> "std::unordered_map< std::int64_t,std::vector< std::string > >::iterator":
        return _cstl.MapLongVecStr_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongVecStr

# Register MapLongVecStr in _cstl:
_cstl.MapLongVecStr_swigregister(MapLongVecStr)

class MapLongVecFloat(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongVecFloat_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongVecFloat___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongVecFloat___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::vector< float > >::size_type":
        return _cstl.MapLongVecFloat___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::vector< float > >::key_type const &") -> "std::unordered_map< std::int64_t,std::vector< float > >::mapped_type const &":
        return _cstl.MapLongVecFloat___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::vector< float > >::key_type const &") -> "void":
        return _cstl.MapLongVecFloat___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::vector< float > >::key_type const &") -> "bool":
        return _cstl.MapLongVecFloat_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongVecFloat_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongVecFloat_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongVecFloat_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::vector< float > >::key_type const &") -> "bool":
        return _cstl.MapLongVecFloat___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongVecFloat_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongVecFloat_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongVecFloat___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongVecFloat_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongVecFloat_swiginit(self, _cstl.new_MapLongVecFloat(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongVecFloat_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::vector< float > >::size_type":
        return _cstl.MapLongVecFloat_size(self)

    def swap(self, v: "MapLongVecFloat") -> "void":
        return _cstl.MapLongVecFloat_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::vector< float > >::iterator":
        return _cstl.MapLongVecFloat_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::vector< float > >::iterator":
        return _cstl.MapLongVecFloat_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongVecFloat_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::vector< float > >::allocator_type":
        return _cstl.MapLongVecFloat_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::vector< float > >::key_type const &") -> "std::unordered_map< std::int64_t,std::vector< float > >::size_type":
        return _cstl.MapLongVecFloat_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongVecFloat_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::vector< float > >::key_type const &") -> "std::unordered_map< std::int64_t,std::vector< float > >::iterator":
        return _cstl.MapLongVecFloat_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongVecFloat

# Register MapLongVecFloat in _cstl:
_cstl.MapLongVecFloat_swigregister(MapLongVecFloat)

class MapLongVecDouble(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongVecDouble_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongVecDouble___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongVecDouble___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::vector< double > >::size_type":
        return _cstl.MapLongVecDouble___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::vector< double > >::key_type const &") -> "std::unordered_map< std::int64_t,std::vector< double > >::mapped_type const &":
        return _cstl.MapLongVecDouble___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::vector< double > >::key_type const &") -> "void":
        return _cstl.MapLongVecDouble___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::vector< double > >::key_type const &") -> "bool":
        return _cstl.MapLongVecDouble_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongVecDouble_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongVecDouble_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongVecDouble_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::vector< double > >::key_type const &") -> "bool":
        return _cstl.MapLongVecDouble___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongVecDouble_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongVecDouble_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongVecDouble___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongVecDouble_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongVecDouble_swiginit(self, _cstl.new_MapLongVecDouble(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongVecDouble_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::vector< double > >::size_type":
        return _cstl.MapLongVecDouble_size(self)

    def swap(self, v: "MapLongVecDouble") -> "void":
        return _cstl.MapLongVecDouble_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::vector< double > >::iterator":
        return _cstl.MapLongVecDouble_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::vector< double > >::iterator":
        return _cstl.MapLongVecDouble_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongVecDouble_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::vector< double > >::allocator_type":
        return _cstl.MapLongVecDouble_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::vector< double > >::key_type const &") -> "std::unordered_map< std::int64_t,std::vector< double > >::size_type":
        return _cstl.MapLongVecDouble_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongVecDouble_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::vector< double > >::key_type const &") -> "std::unordered_map< std::int64_t,std::vector< double > >::iterator":
        return _cstl.MapLongVecDouble_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongVecDouble

# Register MapLongVecDouble in _cstl:
_cstl.MapLongVecDouble_swigregister(MapLongVecDouble)

class MapLongVecBool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongVecBool_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongVecBool___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongVecBool___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::vector< bool > >::size_type":
        return _cstl.MapLongVecBool___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::vector< bool > >::key_type const &") -> "std::unordered_map< std::int64_t,std::vector< bool > >::mapped_type const &":
        return _cstl.MapLongVecBool___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::vector< bool > >::key_type const &") -> "void":
        return _cstl.MapLongVecBool___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::vector< bool > >::key_type const &") -> "bool":
        return _cstl.MapLongVecBool_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongVecBool_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongVecBool_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongVecBool_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::vector< bool > >::key_type const &") -> "bool":
        return _cstl.MapLongVecBool___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongVecBool_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongVecBool_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongVecBool___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongVecBool_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongVecBool_swiginit(self, _cstl.new_MapLongVecBool(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongVecBool_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::vector< bool > >::size_type":
        return _cstl.MapLongVecBool_size(self)

    def swap(self, v: "MapLongVecBool") -> "void":
        return _cstl.MapLongVecBool_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::vector< bool > >::iterator":
        return _cstl.MapLongVecBool_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::vector< bool > >::iterator":
        return _cstl.MapLongVecBool_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongVecBool_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::vector< bool > >::allocator_type":
        return _cstl.MapLongVecBool_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::vector< bool > >::key_type const &") -> "std::unordered_map< std::int64_t,std::vector< bool > >::size_type":
        return _cstl.MapLongVecBool_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongVecBool_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::vector< bool > >::key_type const &") -> "std::unordered_map< std::int64_t,std::vector< bool > >::iterator":
        return _cstl.MapLongVecBool_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongVecBool

# Register MapLongVecBool in _cstl:
_cstl.MapLongVecBool_swigregister(MapLongVecBool)

class MapLongVecLong(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongVecLong_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongVecLong___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongVecLong___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::vector< std::int64_t > >::size_type":
        return _cstl.MapLongVecLong___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::vector< std::int64_t > >::key_type const &") -> "std::unordered_map< std::int64_t,std::vector< std::int64_t > >::mapped_type const &":
        return _cstl.MapLongVecLong___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::vector< std::int64_t > >::key_type const &") -> "void":
        return _cstl.MapLongVecLong___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::vector< std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapLongVecLong_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongVecLong_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongVecLong_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongVecLong_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::vector< std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapLongVecLong___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongVecLong_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongVecLong_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongVecLong___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongVecLong_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongVecLong_swiginit(self, _cstl.new_MapLongVecLong(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongVecLong_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::vector< std::int64_t > >::size_type":
        return _cstl.MapLongVecLong_size(self)

    def swap(self, v: "MapLongVecLong") -> "void":
        return _cstl.MapLongVecLong_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::vector< std::int64_t > >::iterator":
        return _cstl.MapLongVecLong_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::vector< std::int64_t > >::iterator":
        return _cstl.MapLongVecLong_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongVecLong_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::vector< std::int64_t > >::allocator_type":
        return _cstl.MapLongVecLong_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::vector< std::int64_t > >::key_type const &") -> "std::unordered_map< std::int64_t,std::vector< std::int64_t > >::size_type":
        return _cstl.MapLongVecLong_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongVecLong_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::vector< std::int64_t > >::key_type const &") -> "std::unordered_map< std::int64_t,std::vector< std::int64_t > >::iterator":
        return _cstl.MapLongVecLong_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongVecLong

# Register MapLongVecLong in _cstl:
_cstl.MapLongVecLong_swigregister(MapLongVecLong)

class MapLongSetInt(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongSetInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongSetInt___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongSetInt___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::unordered_set< int > >::size_type":
        return _cstl.MapLongSetInt___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_set< int > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_set< int > >::mapped_type const &":
        return _cstl.MapLongSetInt___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_set< int > >::key_type const &") -> "void":
        return _cstl.MapLongSetInt___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::unordered_set< int > >::key_type const &") -> "bool":
        return _cstl.MapLongSetInt_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongSetInt_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongSetInt_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongSetInt_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::unordered_set< int > >::key_type const &") -> "bool":
        return _cstl.MapLongSetInt___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongSetInt_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongSetInt_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongSetInt___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongSetInt_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongSetInt_swiginit(self, _cstl.new_MapLongSetInt(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongSetInt_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::unordered_set< int > >::size_type":
        return _cstl.MapLongSetInt_size(self)

    def swap(self, v: "MapLongSetInt") -> "void":
        return _cstl.MapLongSetInt_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::unordered_set< int > >::iterator":
        return _cstl.MapLongSetInt_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::unordered_set< int > >::iterator":
        return _cstl.MapLongSetInt_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongSetInt_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::unordered_set< int > >::allocator_type":
        return _cstl.MapLongSetInt_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::unordered_set< int > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_set< int > >::size_type":
        return _cstl.MapLongSetInt_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongSetInt_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::unordered_set< int > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_set< int > >::iterator":
        return _cstl.MapLongSetInt_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongSetInt

# Register MapLongSetInt in _cstl:
_cstl.MapLongSetInt_swigregister(MapLongSetInt)

class MapLongSetStr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongSetStr_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongSetStr___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongSetStr___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::unordered_set< std::string > >::size_type":
        return _cstl.MapLongSetStr___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_set< std::string > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_set< std::string > >::mapped_type const &":
        return _cstl.MapLongSetStr___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_set< std::string > >::key_type const &") -> "void":
        return _cstl.MapLongSetStr___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::unordered_set< std::string > >::key_type const &") -> "bool":
        return _cstl.MapLongSetStr_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongSetStr_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongSetStr_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongSetStr_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::unordered_set< std::string > >::key_type const &") -> "bool":
        return _cstl.MapLongSetStr___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongSetStr_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongSetStr_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongSetStr___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongSetStr_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongSetStr_swiginit(self, _cstl.new_MapLongSetStr(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongSetStr_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::unordered_set< std::string > >::size_type":
        return _cstl.MapLongSetStr_size(self)

    def swap(self, v: "MapLongSetStr") -> "void":
        return _cstl.MapLongSetStr_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::unordered_set< std::string > >::iterator":
        return _cstl.MapLongSetStr_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::unordered_set< std::string > >::iterator":
        return _cstl.MapLongSetStr_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongSetStr_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::unordered_set< std::string > >::allocator_type":
        return _cstl.MapLongSetStr_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::unordered_set< std::string > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_set< std::string > >::size_type":
        return _cstl.MapLongSetStr_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongSetStr_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::unordered_set< std::string > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_set< std::string > >::iterator":
        return _cstl.MapLongSetStr_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongSetStr

# Register MapLongSetStr in _cstl:
_cstl.MapLongSetStr_swigregister(MapLongSetStr)

class MapLongSetLong(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongSetLong_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongSetLong___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongSetLong___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::unordered_set< std::int64_t > >::size_type":
        return _cstl.MapLongSetLong___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_set< std::int64_t > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_set< std::int64_t > >::mapped_type const &":
        return _cstl.MapLongSetLong___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_set< std::int64_t > >::key_type const &") -> "void":
        return _cstl.MapLongSetLong___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::unordered_set< std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapLongSetLong_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongSetLong_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongSetLong_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongSetLong_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::unordered_set< std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapLongSetLong___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongSetLong_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongSetLong_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongSetLong___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongSetLong_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongSetLong_swiginit(self, _cstl.new_MapLongSetLong(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongSetLong_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::unordered_set< std::int64_t > >::size_type":
        return _cstl.MapLongSetLong_size(self)

    def swap(self, v: "MapLongSetLong") -> "void":
        return _cstl.MapLongSetLong_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::unordered_set< std::int64_t > >::iterator":
        return _cstl.MapLongSetLong_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::unordered_set< std::int64_t > >::iterator":
        return _cstl.MapLongSetLong_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongSetLong_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::unordered_set< std::int64_t > >::allocator_type":
        return _cstl.MapLongSetLong_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::unordered_set< std::int64_t > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_set< std::int64_t > >::size_type":
        return _cstl.MapLongSetLong_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongSetLong_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::unordered_set< std::int64_t > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_set< std::int64_t > >::iterator":
        return _cstl.MapLongSetLong_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongSetLong

# Register MapLongSetLong in _cstl:
_cstl.MapLongSetLong_swigregister(MapLongSetLong)

class MapLongMapIntInt(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapIntInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongMapIntInt___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongMapIntInt___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,int > >::size_type":
        return _cstl.MapLongMapIntInt___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< int,int > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< int,int > >::mapped_type const &":
        return _cstl.MapLongMapIntInt___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< int,int > >::key_type const &") -> "void":
        return _cstl.MapLongMapIntInt___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::unordered_map< int,int > >::key_type const &") -> "bool":
        return _cstl.MapLongMapIntInt_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongMapIntInt_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongMapIntInt_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongMapIntInt_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< int,int > >::key_type const &") -> "bool":
        return _cstl.MapLongMapIntInt___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapIntInt_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapIntInt_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongMapIntInt___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongMapIntInt_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongMapIntInt_swiginit(self, _cstl.new_MapLongMapIntInt(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongMapIntInt_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,int > >::size_type":
        return _cstl.MapLongMapIntInt_size(self)

    def swap(self, v: "MapLongMapIntInt") -> "void":
        return _cstl.MapLongMapIntInt_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,int > >::iterator":
        return _cstl.MapLongMapIntInt_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,int > >::iterator":
        return _cstl.MapLongMapIntInt_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongMapIntInt_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,int > >::allocator_type":
        return _cstl.MapLongMapIntInt_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::unordered_map< int,int > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< int,int > >::size_type":
        return _cstl.MapLongMapIntInt_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongMapIntInt_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::unordered_map< int,int > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< int,int > >::iterator":
        return _cstl.MapLongMapIntInt_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongMapIntInt

# Register MapLongMapIntInt in _cstl:
_cstl.MapLongMapIntInt_swigregister(MapLongMapIntInt)

class MapLongMapIntStr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapIntStr_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongMapIntStr___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongMapIntStr___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,std::string > >::size_type":
        return _cstl.MapLongMapIntStr___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< int,std::string > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< int,std::string > >::mapped_type const &":
        return _cstl.MapLongMapIntStr___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< int,std::string > >::key_type const &") -> "void":
        return _cstl.MapLongMapIntStr___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::unordered_map< int,std::string > >::key_type const &") -> "bool":
        return _cstl.MapLongMapIntStr_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongMapIntStr_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongMapIntStr_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongMapIntStr_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< int,std::string > >::key_type const &") -> "bool":
        return _cstl.MapLongMapIntStr___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapIntStr_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapIntStr_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongMapIntStr___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongMapIntStr_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongMapIntStr_swiginit(self, _cstl.new_MapLongMapIntStr(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongMapIntStr_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,std::string > >::size_type":
        return _cstl.MapLongMapIntStr_size(self)

    def swap(self, v: "MapLongMapIntStr") -> "void":
        return _cstl.MapLongMapIntStr_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,std::string > >::iterator":
        return _cstl.MapLongMapIntStr_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,std::string > >::iterator":
        return _cstl.MapLongMapIntStr_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongMapIntStr_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,std::string > >::allocator_type":
        return _cstl.MapLongMapIntStr_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::unordered_map< int,std::string > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< int,std::string > >::size_type":
        return _cstl.MapLongMapIntStr_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongMapIntStr_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::unordered_map< int,std::string > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< int,std::string > >::iterator":
        return _cstl.MapLongMapIntStr_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongMapIntStr

# Register MapLongMapIntStr in _cstl:
_cstl.MapLongMapIntStr_swigregister(MapLongMapIntStr)

class MapLongMapIntFloat(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapIntFloat_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongMapIntFloat___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongMapIntFloat___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,float > >::size_type":
        return _cstl.MapLongMapIntFloat___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< int,float > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< int,float > >::mapped_type const &":
        return _cstl.MapLongMapIntFloat___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< int,float > >::key_type const &") -> "void":
        return _cstl.MapLongMapIntFloat___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::unordered_map< int,float > >::key_type const &") -> "bool":
        return _cstl.MapLongMapIntFloat_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongMapIntFloat_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongMapIntFloat_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongMapIntFloat_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< int,float > >::key_type const &") -> "bool":
        return _cstl.MapLongMapIntFloat___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapIntFloat_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapIntFloat_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongMapIntFloat___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongMapIntFloat_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongMapIntFloat_swiginit(self, _cstl.new_MapLongMapIntFloat(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongMapIntFloat_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,float > >::size_type":
        return _cstl.MapLongMapIntFloat_size(self)

    def swap(self, v: "MapLongMapIntFloat") -> "void":
        return _cstl.MapLongMapIntFloat_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,float > >::iterator":
        return _cstl.MapLongMapIntFloat_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,float > >::iterator":
        return _cstl.MapLongMapIntFloat_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongMapIntFloat_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,float > >::allocator_type":
        return _cstl.MapLongMapIntFloat_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::unordered_map< int,float > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< int,float > >::size_type":
        return _cstl.MapLongMapIntFloat_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongMapIntFloat_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::unordered_map< int,float > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< int,float > >::iterator":
        return _cstl.MapLongMapIntFloat_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongMapIntFloat

# Register MapLongMapIntFloat in _cstl:
_cstl.MapLongMapIntFloat_swigregister(MapLongMapIntFloat)

class MapLongMapIntDouble(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapIntDouble_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongMapIntDouble___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongMapIntDouble___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,double > >::size_type":
        return _cstl.MapLongMapIntDouble___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< int,double > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< int,double > >::mapped_type const &":
        return _cstl.MapLongMapIntDouble___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< int,double > >::key_type const &") -> "void":
        return _cstl.MapLongMapIntDouble___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::unordered_map< int,double > >::key_type const &") -> "bool":
        return _cstl.MapLongMapIntDouble_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongMapIntDouble_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongMapIntDouble_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongMapIntDouble_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< int,double > >::key_type const &") -> "bool":
        return _cstl.MapLongMapIntDouble___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapIntDouble_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapIntDouble_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongMapIntDouble___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongMapIntDouble_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongMapIntDouble_swiginit(self, _cstl.new_MapLongMapIntDouble(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongMapIntDouble_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,double > >::size_type":
        return _cstl.MapLongMapIntDouble_size(self)

    def swap(self, v: "MapLongMapIntDouble") -> "void":
        return _cstl.MapLongMapIntDouble_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,double > >::iterator":
        return _cstl.MapLongMapIntDouble_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,double > >::iterator":
        return _cstl.MapLongMapIntDouble_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongMapIntDouble_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,double > >::allocator_type":
        return _cstl.MapLongMapIntDouble_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::unordered_map< int,double > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< int,double > >::size_type":
        return _cstl.MapLongMapIntDouble_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongMapIntDouble_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::unordered_map< int,double > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< int,double > >::iterator":
        return _cstl.MapLongMapIntDouble_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongMapIntDouble

# Register MapLongMapIntDouble in _cstl:
_cstl.MapLongMapIntDouble_swigregister(MapLongMapIntDouble)

class MapLongMapIntBool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapIntBool_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongMapIntBool___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongMapIntBool___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,bool > >::size_type":
        return _cstl.MapLongMapIntBool___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< int,bool > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< int,bool > >::mapped_type const &":
        return _cstl.MapLongMapIntBool___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< int,bool > >::key_type const &") -> "void":
        return _cstl.MapLongMapIntBool___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::unordered_map< int,bool > >::key_type const &") -> "bool":
        return _cstl.MapLongMapIntBool_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongMapIntBool_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongMapIntBool_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongMapIntBool_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< int,bool > >::key_type const &") -> "bool":
        return _cstl.MapLongMapIntBool___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapIntBool_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapIntBool_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongMapIntBool___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongMapIntBool_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongMapIntBool_swiginit(self, _cstl.new_MapLongMapIntBool(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongMapIntBool_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,bool > >::size_type":
        return _cstl.MapLongMapIntBool_size(self)

    def swap(self, v: "MapLongMapIntBool") -> "void":
        return _cstl.MapLongMapIntBool_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,bool > >::iterator":
        return _cstl.MapLongMapIntBool_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,bool > >::iterator":
        return _cstl.MapLongMapIntBool_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongMapIntBool_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,bool > >::allocator_type":
        return _cstl.MapLongMapIntBool_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::unordered_map< int,bool > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< int,bool > >::size_type":
        return _cstl.MapLongMapIntBool_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongMapIntBool_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::unordered_map< int,bool > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< int,bool > >::iterator":
        return _cstl.MapLongMapIntBool_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongMapIntBool

# Register MapLongMapIntBool in _cstl:
_cstl.MapLongMapIntBool_swigregister(MapLongMapIntBool)

class MapLongMapIntLong(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapIntLong_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongMapIntLong___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongMapIntLong___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,std::int64_t > >::size_type":
        return _cstl.MapLongMapIntLong___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< int,std::int64_t > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< int,std::int64_t > >::mapped_type const &":
        return _cstl.MapLongMapIntLong___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< int,std::int64_t > >::key_type const &") -> "void":
        return _cstl.MapLongMapIntLong___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::unordered_map< int,std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapLongMapIntLong_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongMapIntLong_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongMapIntLong_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongMapIntLong_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< int,std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapLongMapIntLong___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapIntLong_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapIntLong_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongMapIntLong___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongMapIntLong_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongMapIntLong_swiginit(self, _cstl.new_MapLongMapIntLong(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongMapIntLong_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,std::int64_t > >::size_type":
        return _cstl.MapLongMapIntLong_size(self)

    def swap(self, v: "MapLongMapIntLong") -> "void":
        return _cstl.MapLongMapIntLong_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,std::int64_t > >::iterator":
        return _cstl.MapLongMapIntLong_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,std::int64_t > >::iterator":
        return _cstl.MapLongMapIntLong_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongMapIntLong_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::unordered_map< int,std::int64_t > >::allocator_type":
        return _cstl.MapLongMapIntLong_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::unordered_map< int,std::int64_t > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< int,std::int64_t > >::size_type":
        return _cstl.MapLongMapIntLong_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongMapIntLong_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::unordered_map< int,std::int64_t > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< int,std::int64_t > >::iterator":
        return _cstl.MapLongMapIntLong_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongMapIntLong

# Register MapLongMapIntLong in _cstl:
_cstl.MapLongMapIntLong_swigregister(MapLongMapIntLong)

class MapLongMapStrInt(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapStrInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongMapStrInt___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongMapStrInt___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,int > >::size_type":
        return _cstl.MapLongMapStrInt___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::string,int > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,int > >::mapped_type const &":
        return _cstl.MapLongMapStrInt___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::string,int > >::key_type const &") -> "void":
        return _cstl.MapLongMapStrInt___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::string,int > >::key_type const &") -> "bool":
        return _cstl.MapLongMapStrInt_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongMapStrInt_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongMapStrInt_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongMapStrInt_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::string,int > >::key_type const &") -> "bool":
        return _cstl.MapLongMapStrInt___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapStrInt_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapStrInt_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongMapStrInt___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongMapStrInt_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongMapStrInt_swiginit(self, _cstl.new_MapLongMapStrInt(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongMapStrInt_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,int > >::size_type":
        return _cstl.MapLongMapStrInt_size(self)

    def swap(self, v: "MapLongMapStrInt") -> "void":
        return _cstl.MapLongMapStrInt_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,int > >::iterator":
        return _cstl.MapLongMapStrInt_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,int > >::iterator":
        return _cstl.MapLongMapStrInt_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongMapStrInt_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,int > >::allocator_type":
        return _cstl.MapLongMapStrInt_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::unordered_map< std::string,int > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,int > >::size_type":
        return _cstl.MapLongMapStrInt_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongMapStrInt_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::unordered_map< std::string,int > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,int > >::iterator":
        return _cstl.MapLongMapStrInt_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongMapStrInt

# Register MapLongMapStrInt in _cstl:
_cstl.MapLongMapStrInt_swigregister(MapLongMapStrInt)

class MapLongMapStrStr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapStrStr_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongMapStrStr___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongMapStrStr___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,std::string > >::size_type":
        return _cstl.MapLongMapStrStr___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::string,std::string > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,std::string > >::mapped_type const &":
        return _cstl.MapLongMapStrStr___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::string,std::string > >::key_type const &") -> "void":
        return _cstl.MapLongMapStrStr___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::string,std::string > >::key_type const &") -> "bool":
        return _cstl.MapLongMapStrStr_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongMapStrStr_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongMapStrStr_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongMapStrStr_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::string,std::string > >::key_type const &") -> "bool":
        return _cstl.MapLongMapStrStr___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapStrStr_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapStrStr_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongMapStrStr___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongMapStrStr_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongMapStrStr_swiginit(self, _cstl.new_MapLongMapStrStr(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongMapStrStr_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,std::string > >::size_type":
        return _cstl.MapLongMapStrStr_size(self)

    def swap(self, v: "MapLongMapStrStr") -> "void":
        return _cstl.MapLongMapStrStr_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,std::string > >::iterator":
        return _cstl.MapLongMapStrStr_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,std::string > >::iterator":
        return _cstl.MapLongMapStrStr_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongMapStrStr_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,std::string > >::allocator_type":
        return _cstl.MapLongMapStrStr_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::unordered_map< std::string,std::string > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,std::string > >::size_type":
        return _cstl.MapLongMapStrStr_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongMapStrStr_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::unordered_map< std::string,std::string > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,std::string > >::iterator":
        return _cstl.MapLongMapStrStr_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongMapStrStr

# Register MapLongMapStrStr in _cstl:
_cstl.MapLongMapStrStr_swigregister(MapLongMapStrStr)

class MapLongMapStrFloat(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapStrFloat_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongMapStrFloat___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongMapStrFloat___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,float > >::size_type":
        return _cstl.MapLongMapStrFloat___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::string,float > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,float > >::mapped_type const &":
        return _cstl.MapLongMapStrFloat___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::string,float > >::key_type const &") -> "void":
        return _cstl.MapLongMapStrFloat___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::string,float > >::key_type const &") -> "bool":
        return _cstl.MapLongMapStrFloat_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongMapStrFloat_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongMapStrFloat_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongMapStrFloat_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::string,float > >::key_type const &") -> "bool":
        return _cstl.MapLongMapStrFloat___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapStrFloat_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapStrFloat_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongMapStrFloat___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongMapStrFloat_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongMapStrFloat_swiginit(self, _cstl.new_MapLongMapStrFloat(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongMapStrFloat_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,float > >::size_type":
        return _cstl.MapLongMapStrFloat_size(self)

    def swap(self, v: "MapLongMapStrFloat") -> "void":
        return _cstl.MapLongMapStrFloat_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,float > >::iterator":
        return _cstl.MapLongMapStrFloat_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,float > >::iterator":
        return _cstl.MapLongMapStrFloat_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongMapStrFloat_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,float > >::allocator_type":
        return _cstl.MapLongMapStrFloat_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::unordered_map< std::string,float > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,float > >::size_type":
        return _cstl.MapLongMapStrFloat_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongMapStrFloat_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::unordered_map< std::string,float > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,float > >::iterator":
        return _cstl.MapLongMapStrFloat_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongMapStrFloat

# Register MapLongMapStrFloat in _cstl:
_cstl.MapLongMapStrFloat_swigregister(MapLongMapStrFloat)

class MapLongMapStrDouble(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapStrDouble_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongMapStrDouble___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongMapStrDouble___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,double > >::size_type":
        return _cstl.MapLongMapStrDouble___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::string,double > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,double > >::mapped_type const &":
        return _cstl.MapLongMapStrDouble___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::string,double > >::key_type const &") -> "void":
        return _cstl.MapLongMapStrDouble___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::string,double > >::key_type const &") -> "bool":
        return _cstl.MapLongMapStrDouble_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongMapStrDouble_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongMapStrDouble_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongMapStrDouble_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::string,double > >::key_type const &") -> "bool":
        return _cstl.MapLongMapStrDouble___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapStrDouble_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapStrDouble_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongMapStrDouble___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongMapStrDouble_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongMapStrDouble_swiginit(self, _cstl.new_MapLongMapStrDouble(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongMapStrDouble_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,double > >::size_type":
        return _cstl.MapLongMapStrDouble_size(self)

    def swap(self, v: "MapLongMapStrDouble") -> "void":
        return _cstl.MapLongMapStrDouble_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,double > >::iterator":
        return _cstl.MapLongMapStrDouble_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,double > >::iterator":
        return _cstl.MapLongMapStrDouble_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongMapStrDouble_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,double > >::allocator_type":
        return _cstl.MapLongMapStrDouble_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::unordered_map< std::string,double > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,double > >::size_type":
        return _cstl.MapLongMapStrDouble_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongMapStrDouble_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::unordered_map< std::string,double > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,double > >::iterator":
        return _cstl.MapLongMapStrDouble_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongMapStrDouble

# Register MapLongMapStrDouble in _cstl:
_cstl.MapLongMapStrDouble_swigregister(MapLongMapStrDouble)

class MapLongMapStrBool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapStrBool_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongMapStrBool___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongMapStrBool___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,bool > >::size_type":
        return _cstl.MapLongMapStrBool___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::string,bool > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,bool > >::mapped_type const &":
        return _cstl.MapLongMapStrBool___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::string,bool > >::key_type const &") -> "void":
        return _cstl.MapLongMapStrBool___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::string,bool > >::key_type const &") -> "bool":
        return _cstl.MapLongMapStrBool_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongMapStrBool_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongMapStrBool_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongMapStrBool_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::string,bool > >::key_type const &") -> "bool":
        return _cstl.MapLongMapStrBool___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapStrBool_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapStrBool_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongMapStrBool___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongMapStrBool_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongMapStrBool_swiginit(self, _cstl.new_MapLongMapStrBool(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongMapStrBool_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,bool > >::size_type":
        return _cstl.MapLongMapStrBool_size(self)

    def swap(self, v: "MapLongMapStrBool") -> "void":
        return _cstl.MapLongMapStrBool_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,bool > >::iterator":
        return _cstl.MapLongMapStrBool_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,bool > >::iterator":
        return _cstl.MapLongMapStrBool_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongMapStrBool_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,bool > >::allocator_type":
        return _cstl.MapLongMapStrBool_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::unordered_map< std::string,bool > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,bool > >::size_type":
        return _cstl.MapLongMapStrBool_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongMapStrBool_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::unordered_map< std::string,bool > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,bool > >::iterator":
        return _cstl.MapLongMapStrBool_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongMapStrBool

# Register MapLongMapStrBool in _cstl:
_cstl.MapLongMapStrBool_swigregister(MapLongMapStrBool)

class MapLongMapStrLong(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapStrLong_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongMapStrLong___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongMapStrLong___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,std::int64_t > >::size_type":
        return _cstl.MapLongMapStrLong___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::string,std::int64_t > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,std::int64_t > >::mapped_type const &":
        return _cstl.MapLongMapStrLong___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::string,std::int64_t > >::key_type const &") -> "void":
        return _cstl.MapLongMapStrLong___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::string,std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapLongMapStrLong_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongMapStrLong_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongMapStrLong_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongMapStrLong_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::string,std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapLongMapStrLong___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapStrLong_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapStrLong_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongMapStrLong___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongMapStrLong_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongMapStrLong_swiginit(self, _cstl.new_MapLongMapStrLong(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongMapStrLong_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,std::int64_t > >::size_type":
        return _cstl.MapLongMapStrLong_size(self)

    def swap(self, v: "MapLongMapStrLong") -> "void":
        return _cstl.MapLongMapStrLong_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,std::int64_t > >::iterator":
        return _cstl.MapLongMapStrLong_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,std::int64_t > >::iterator":
        return _cstl.MapLongMapStrLong_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongMapStrLong_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,std::int64_t > >::allocator_type":
        return _cstl.MapLongMapStrLong_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::unordered_map< std::string,std::int64_t > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,std::int64_t > >::size_type":
        return _cstl.MapLongMapStrLong_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongMapStrLong_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::unordered_map< std::string,std::int64_t > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::string,std::int64_t > >::iterator":
        return _cstl.MapLongMapStrLong_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongMapStrLong

# Register MapLongMapStrLong in _cstl:
_cstl.MapLongMapStrLong_swigregister(MapLongMapStrLong)

class MapLongMapLongInt(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapLongInt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongMapLongInt___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongMapLongInt___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,int > >::size_type":
        return _cstl.MapLongMapLongInt___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,int > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,int > >::mapped_type const &":
        return _cstl.MapLongMapLongInt___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,int > >::key_type const &") -> "void":
        return _cstl.MapLongMapLongInt___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,int > >::key_type const &") -> "bool":
        return _cstl.MapLongMapLongInt_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongMapLongInt_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongMapLongInt_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongMapLongInt_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,int > >::key_type const &") -> "bool":
        return _cstl.MapLongMapLongInt___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapLongInt_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapLongInt_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongMapLongInt___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongMapLongInt_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongMapLongInt_swiginit(self, _cstl.new_MapLongMapLongInt(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongMapLongInt_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,int > >::size_type":
        return _cstl.MapLongMapLongInt_size(self)

    def swap(self, v: "MapLongMapLongInt") -> "void":
        return _cstl.MapLongMapLongInt_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,int > >::iterator":
        return _cstl.MapLongMapLongInt_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,int > >::iterator":
        return _cstl.MapLongMapLongInt_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongMapLongInt_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,int > >::allocator_type":
        return _cstl.MapLongMapLongInt_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,int > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,int > >::size_type":
        return _cstl.MapLongMapLongInt_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongMapLongInt_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,int > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,int > >::iterator":
        return _cstl.MapLongMapLongInt_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongMapLongInt

# Register MapLongMapLongInt in _cstl:
_cstl.MapLongMapLongInt_swigregister(MapLongMapLongInt)

class MapLongMapLongStr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapLongStr_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongMapLongStr___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongMapLongStr___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,std::string > >::size_type":
        return _cstl.MapLongMapLongStr___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,std::string > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,std::string > >::mapped_type const &":
        return _cstl.MapLongMapLongStr___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,std::string > >::key_type const &") -> "void":
        return _cstl.MapLongMapLongStr___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,std::string > >::key_type const &") -> "bool":
        return _cstl.MapLongMapLongStr_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongMapLongStr_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongMapLongStr_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongMapLongStr_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,std::string > >::key_type const &") -> "bool":
        return _cstl.MapLongMapLongStr___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapLongStr_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapLongStr_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongMapLongStr___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongMapLongStr_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongMapLongStr_swiginit(self, _cstl.new_MapLongMapLongStr(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongMapLongStr_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,std::string > >::size_type":
        return _cstl.MapLongMapLongStr_size(self)

    def swap(self, v: "MapLongMapLongStr") -> "void":
        return _cstl.MapLongMapLongStr_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,std::string > >::iterator":
        return _cstl.MapLongMapLongStr_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,std::string > >::iterator":
        return _cstl.MapLongMapLongStr_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongMapLongStr_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,std::string > >::allocator_type":
        return _cstl.MapLongMapLongStr_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,std::string > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,std::string > >::size_type":
        return _cstl.MapLongMapLongStr_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongMapLongStr_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,std::string > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,std::string > >::iterator":
        return _cstl.MapLongMapLongStr_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongMapLongStr

# Register MapLongMapLongStr in _cstl:
_cstl.MapLongMapLongStr_swigregister(MapLongMapLongStr)

class MapLongMapLongFloat(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapLongFloat_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongMapLongFloat___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongMapLongFloat___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,float > >::size_type":
        return _cstl.MapLongMapLongFloat___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,float > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,float > >::mapped_type const &":
        return _cstl.MapLongMapLongFloat___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,float > >::key_type const &") -> "void":
        return _cstl.MapLongMapLongFloat___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,float > >::key_type const &") -> "bool":
        return _cstl.MapLongMapLongFloat_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongMapLongFloat_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongMapLongFloat_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongMapLongFloat_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,float > >::key_type const &") -> "bool":
        return _cstl.MapLongMapLongFloat___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapLongFloat_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapLongFloat_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongMapLongFloat___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongMapLongFloat_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongMapLongFloat_swiginit(self, _cstl.new_MapLongMapLongFloat(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongMapLongFloat_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,float > >::size_type":
        return _cstl.MapLongMapLongFloat_size(self)

    def swap(self, v: "MapLongMapLongFloat") -> "void":
        return _cstl.MapLongMapLongFloat_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,float > >::iterator":
        return _cstl.MapLongMapLongFloat_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,float > >::iterator":
        return _cstl.MapLongMapLongFloat_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongMapLongFloat_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,float > >::allocator_type":
        return _cstl.MapLongMapLongFloat_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,float > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,float > >::size_type":
        return _cstl.MapLongMapLongFloat_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongMapLongFloat_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,float > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,float > >::iterator":
        return _cstl.MapLongMapLongFloat_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongMapLongFloat

# Register MapLongMapLongFloat in _cstl:
_cstl.MapLongMapLongFloat_swigregister(MapLongMapLongFloat)

class MapLongMapLongDouble(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapLongDouble_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongMapLongDouble___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongMapLongDouble___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,double > >::size_type":
        return _cstl.MapLongMapLongDouble___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,double > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,double > >::mapped_type const &":
        return _cstl.MapLongMapLongDouble___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,double > >::key_type const &") -> "void":
        return _cstl.MapLongMapLongDouble___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,double > >::key_type const &") -> "bool":
        return _cstl.MapLongMapLongDouble_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongMapLongDouble_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongMapLongDouble_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongMapLongDouble_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,double > >::key_type const &") -> "bool":
        return _cstl.MapLongMapLongDouble___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapLongDouble_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapLongDouble_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongMapLongDouble___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongMapLongDouble_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongMapLongDouble_swiginit(self, _cstl.new_MapLongMapLongDouble(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongMapLongDouble_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,double > >::size_type":
        return _cstl.MapLongMapLongDouble_size(self)

    def swap(self, v: "MapLongMapLongDouble") -> "void":
        return _cstl.MapLongMapLongDouble_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,double > >::iterator":
        return _cstl.MapLongMapLongDouble_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,double > >::iterator":
        return _cstl.MapLongMapLongDouble_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongMapLongDouble_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,double > >::allocator_type":
        return _cstl.MapLongMapLongDouble_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,double > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,double > >::size_type":
        return _cstl.MapLongMapLongDouble_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongMapLongDouble_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,double > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,double > >::iterator":
        return _cstl.MapLongMapLongDouble_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongMapLongDouble

# Register MapLongMapLongDouble in _cstl:
_cstl.MapLongMapLongDouble_swigregister(MapLongMapLongDouble)

class MapLongMapLongBool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapLongBool_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongMapLongBool___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongMapLongBool___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,bool > >::size_type":
        return _cstl.MapLongMapLongBool___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,bool > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,bool > >::mapped_type const &":
        return _cstl.MapLongMapLongBool___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,bool > >::key_type const &") -> "void":
        return _cstl.MapLongMapLongBool___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,bool > >::key_type const &") -> "bool":
        return _cstl.MapLongMapLongBool_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongMapLongBool_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongMapLongBool_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongMapLongBool_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,bool > >::key_type const &") -> "bool":
        return _cstl.MapLongMapLongBool___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapLongBool_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapLongBool_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongMapLongBool___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongMapLongBool_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongMapLongBool_swiginit(self, _cstl.new_MapLongMapLongBool(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongMapLongBool_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,bool > >::size_type":
        return _cstl.MapLongMapLongBool_size(self)

    def swap(self, v: "MapLongMapLongBool") -> "void":
        return _cstl.MapLongMapLongBool_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,bool > >::iterator":
        return _cstl.MapLongMapLongBool_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,bool > >::iterator":
        return _cstl.MapLongMapLongBool_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongMapLongBool_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,bool > >::allocator_type":
        return _cstl.MapLongMapLongBool_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,bool > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,bool > >::size_type":
        return _cstl.MapLongMapLongBool_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongMapLongBool_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,bool > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,bool > >::iterator":
        return _cstl.MapLongMapLongBool_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongMapLongBool

# Register MapLongMapLongBool in _cstl:
_cstl.MapLongMapLongBool_swigregister(MapLongMapLongBool)

class MapLongMapLongLong(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapLongLong_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self) -> "bool":
        return _cstl.MapLongMapLongLong___nonzero__(self)

    def __bool__(self) -> "bool":
        return _cstl.MapLongMapLongLong___bool__(self)

    def __len__(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,std::int64_t > >::size_type":
        return _cstl.MapLongMapLongLong___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,std::int64_t > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,std::int64_t > >::mapped_type const &":
        return _cstl.MapLongMapLongLong___getitem__(self, key)

    def __delitem__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,std::int64_t > >::key_type const &") -> "void":
        return _cstl.MapLongMapLongLong___delitem__(self, key)

    def has_key(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapLongMapLongLong_has_key(self, key)

    def keys(self) -> "PyObject *":
        return _cstl.MapLongMapLongLong_keys(self)

    def values(self) -> "PyObject *":
        return _cstl.MapLongMapLongLong_values(self)

    def items(self) -> "PyObject *":
        return _cstl.MapLongMapLongLong_items(self)

    def __contains__(self, key: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,std::int64_t > >::key_type const &") -> "bool":
        return _cstl.MapLongMapLongLong___contains__(self, key)

    def key_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapLongLong_key_iterator(self)

    def value_iterator(self) -> "swig::SwigPyIterator *":
        return _cstl.MapLongMapLongLong_value_iterator(self)

    def __setitem__(self, *args) -> "void":
        return _cstl.MapLongMapLongLong___setitem__(self, *args)

    def asdict(self) -> "PyObject *":
        return _cstl.MapLongMapLongLong_asdict(self)

    def __init__(self, *args):
        _cstl.MapLongMapLongLong_swiginit(self, _cstl.new_MapLongMapLongLong(*args))

    def empty(self) -> "bool":
        return _cstl.MapLongMapLongLong_empty(self)

    def size(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,std::int64_t > >::size_type":
        return _cstl.MapLongMapLongLong_size(self)

    def swap(self, v: "MapLongMapLongLong") -> "void":
        return _cstl.MapLongMapLongLong_swap(self, v)

    def begin(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,std::int64_t > >::iterator":
        return _cstl.MapLongMapLongLong_begin(self)

    def end(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,std::int64_t > >::iterator":
        return _cstl.MapLongMapLongLong_end(self)

    def clear(self) -> "void":
        return _cstl.MapLongMapLongLong_clear(self)

    def get_allocator(self) -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,std::int64_t > >::allocator_type":
        return _cstl.MapLongMapLongLong_get_allocator(self)

    def count(self, x: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,std::int64_t > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,std::int64_t > >::size_type":
        return _cstl.MapLongMapLongLong_count(self, x)

    def erase(self, *args) -> "void":
        return _cstl.MapLongMapLongLong_erase(self, *args)

    def find(self, x: "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,std::int64_t > >::key_type const &") -> "std::unordered_map< std::int64_t,std::unordered_map< std::int64_t,std::int64_t > >::iterator":
        return _cstl.MapLongMapLongLong_find(self, x)
    __swig_destroy__ = _cstl.delete_MapLongMapLongLong

# Register MapLongMapLongLong in _cstl:
_cstl.MapLongMapLongLong_swigregister(MapLongMapLongLong)



