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


from . import _ITKPyBasePython
import collections

from sys import version_info as _version_info
if _version_info < (3, 7, 0):
    raise RuntimeError("Python 3.7 or later required")

from . import _ITKCommonPython



from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _pyBasePython
else:
    import _pyBasePython

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 == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(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__)


if _swig_python_version_info[0:2] >= (3, 3):
    import collections.abc
else:
    import collections

class SwigPyIterator(object):
    r"""Proxy of C++ swig::SwigPyIterator class."""

    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__ = _pyBasePython.delete_SwigPyIterator

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

    def incr(self, n=1):
        r"""
        incr(self, n=1) -> SwigPyIterator

        Parameters
        ----------
        n: size_t

        """
        return _pyBasePython.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        r"""
        decr(self, n=1) -> SwigPyIterator

        Parameters
        ----------
        n: size_t

        """
        return _pyBasePython.SwigPyIterator_decr(self, n)

    def distance(self, x):
        r"""
        distance(self, x) -> ptrdiff_t

        Parameters
        ----------
        x: swig::SwigPyIterator const &

        """
        return _pyBasePython.SwigPyIterator_distance(self, x)

    def equal(self, x):
        r"""
        equal(self, x) -> bool

        Parameters
        ----------
        x: swig::SwigPyIterator const &

        """
        return _pyBasePython.SwigPyIterator_equal(self, x)

    def copy(self):
        r"""copy(self) -> SwigPyIterator"""
        return _pyBasePython.SwigPyIterator_copy(self)

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

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

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

    def advance(self, n):
        r"""
        advance(self, n) -> SwigPyIterator

        Parameters
        ----------
        n: ptrdiff_t

        """
        return _pyBasePython.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        r"""
        __eq__(self, x) -> bool

        Parameters
        ----------
        x: swig::SwigPyIterator const &

        """
        return _pyBasePython.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        r"""
        __ne__(self, x) -> bool

        Parameters
        ----------
        x: swig::SwigPyIterator const &

        """
        return _pyBasePython.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        r"""
        __iadd__(self, n) -> SwigPyIterator

        Parameters
        ----------
        n: ptrdiff_t

        """
        return _pyBasePython.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        r"""
        __isub__(self, n) -> SwigPyIterator

        Parameters
        ----------
        n: ptrdiff_t

        """
        return _pyBasePython.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        r"""
        __add__(self, n) -> SwigPyIterator

        Parameters
        ----------
        n: ptrdiff_t

        """
        return _pyBasePython.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        r"""
        __sub__(self, n) -> SwigPyIterator

        Parameters
        ----------
        n: ptrdiff_t

        __sub__(self, x) -> ptrdiff_t

        Parameters
        ----------
        x: swig::SwigPyIterator const &

        """
        return _pyBasePython.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _pyBasePython:
_pyBasePython.SwigPyIterator_swigregister(SwigPyIterator)
class ios_base(object):
    r"""Proxy of C++ std::ios_base class."""

    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")
    __repr__ = _swig_repr
    erase_event = _pyBasePython.ios_base_erase_event
    
    imbue_event = _pyBasePython.ios_base_imbue_event
    
    copyfmt_event = _pyBasePython.ios_base_copyfmt_event
    

    def register_callback(self, __fn, __index):
        r"""
        register_callback(self, __fn, __index)

        Parameters
        ----------
        __fn: std::ios_base::event_callback
        __index: int

        """
        return _pyBasePython.ios_base_register_callback(self, __fn, __index)

    def flags(self, *args):
        r"""
        flags(self) -> std::ios_base::fmtflags
        flags(self, __fmtfl) -> std::ios_base::fmtflags

        Parameters
        ----------
        __fmtfl: std::ios_base::fmtflags

        """
        return _pyBasePython.ios_base_flags(self, *args)

    def setf(self, *args):
        r"""
        setf(self, __fmtfl) -> std::ios_base::fmtflags

        Parameters
        ----------
        __fmtfl: std::ios_base::fmtflags

        setf(self, __fmtfl, __mask) -> std::ios_base::fmtflags

        Parameters
        ----------
        __fmtfl: std::ios_base::fmtflags
        __mask: std::ios_base::fmtflags

        """
        return _pyBasePython.ios_base_setf(self, *args)

    def unsetf(self, __mask):
        r"""
        unsetf(self, __mask)

        Parameters
        ----------
        __mask: std::ios_base::fmtflags

        """
        return _pyBasePython.ios_base_unsetf(self, __mask)

    def precision(self, *args):
        r"""
        precision(self) -> std::streamsize
        precision(self, __prec) -> std::streamsize

        Parameters
        ----------
        __prec: std::streamsize

        """
        return _pyBasePython.ios_base_precision(self, *args)

    def width(self, *args):
        r"""
        width(self) -> std::streamsize
        width(self, __wide) -> std::streamsize

        Parameters
        ----------
        __wide: std::streamsize

        """
        return _pyBasePython.ios_base_width(self, *args)

    @staticmethod
    def sync_with_stdio(__sync=True):
        r"""
        sync_with_stdio(__sync=True) -> bool

        Parameters
        ----------
        __sync: bool

        """
        return _pyBasePython.ios_base_sync_with_stdio(__sync)

    def imbue(self, __loc):
        r"""
        imbue(self, __loc) -> std::locale

        Parameters
        ----------
        __loc: std::locale const &

        """
        return _pyBasePython.ios_base_imbue(self, __loc)

    def getloc(self):
        r"""getloc(self) -> std::locale"""
        return _pyBasePython.ios_base_getloc(self)

    @staticmethod
    def xalloc():
        r"""xalloc() -> int"""
        return _pyBasePython.ios_base_xalloc()

    def iword(self, __ix):
        r"""
        iword(self, __ix) -> long &

        Parameters
        ----------
        __ix: int

        """
        return _pyBasePython.ios_base_iword(self, __ix)

    def pword(self, __ix):
        r"""
        pword(self, __ix) -> void *&

        Parameters
        ----------
        __ix: int

        """
        return _pyBasePython.ios_base_pword(self, __ix)
    __swig_destroy__ = _pyBasePython.delete_ios_base

# Register ios_base in _pyBasePython:
_pyBasePython.ios_base_swigregister(ios_base)
cvar = _pyBasePython.cvar
ios_base.boolalpha = _pyBasePython.cvar.ios_base_boolalpha
ios_base.dec = _pyBasePython.cvar.ios_base_dec
ios_base.fixed = _pyBasePython.cvar.ios_base_fixed
ios_base.hex = _pyBasePython.cvar.ios_base_hex
ios_base.internal = _pyBasePython.cvar.ios_base_internal
ios_base.left = _pyBasePython.cvar.ios_base_left
ios_base.oct = _pyBasePython.cvar.ios_base_oct
ios_base.right = _pyBasePython.cvar.ios_base_right
ios_base.scientific = _pyBasePython.cvar.ios_base_scientific
ios_base.showbase = _pyBasePython.cvar.ios_base_showbase
ios_base.showpoint = _pyBasePython.cvar.ios_base_showpoint
ios_base.showpos = _pyBasePython.cvar.ios_base_showpos
ios_base.skipws = _pyBasePython.cvar.ios_base_skipws
ios_base.unitbuf = _pyBasePython.cvar.ios_base_unitbuf
ios_base.uppercase = _pyBasePython.cvar.ios_base_uppercase
ios_base.adjustfield = _pyBasePython.cvar.ios_base_adjustfield
ios_base.basefield = _pyBasePython.cvar.ios_base_basefield
ios_base.floatfield = _pyBasePython.cvar.ios_base_floatfield
ios_base.badbit = _pyBasePython.cvar.ios_base_badbit
ios_base.eofbit = _pyBasePython.cvar.ios_base_eofbit
ios_base.failbit = _pyBasePython.cvar.ios_base_failbit
ios_base.goodbit = _pyBasePython.cvar.ios_base_goodbit
ios_base.app = _pyBasePython.cvar.ios_base_app
ios_base.ate = _pyBasePython.cvar.ios_base_ate
ios_base.binary = _pyBasePython.cvar.ios_base_binary
ios_base.ios_base_in = _pyBasePython.cvar.ios_base_ios_base_in
ios_base.out = _pyBasePython.cvar.ios_base_out
ios_base.trunc = _pyBasePython.cvar.ios_base_trunc
ios_base.beg = _pyBasePython.cvar.ios_base_beg
ios_base.cur = _pyBasePython.cvar.ios_base_cur
ios_base.end = _pyBasePython.cvar.ios_base_end

class ios(ios_base):
    r"""Proxy of C++ std::basic_ios< char > class."""

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

    def rdstate(self):
        r"""rdstate(self) -> std::ios_base::iostate"""
        return _pyBasePython.ios_rdstate(self)

    def clear(self, *args):
        r"""
        clear(self, __state=goodbit)

        Parameters
        ----------
        __state: std::ios_base::iostate

        """
        return _pyBasePython.ios_clear(self, *args)

    def setstate(self, __state):
        r"""
        setstate(self, __state)

        Parameters
        ----------
        __state: std::ios_base::iostate

        """
        return _pyBasePython.ios_setstate(self, __state)

    def good(self):
        r"""good(self) -> bool"""
        return _pyBasePython.ios_good(self)

    def eof(self):
        r"""eof(self) -> bool"""
        return _pyBasePython.ios_eof(self)

    def fail(self):
        r"""fail(self) -> bool"""
        return _pyBasePython.ios_fail(self)

    def bad(self):
        r"""bad(self) -> bool"""
        return _pyBasePython.ios_bad(self)

    def exceptions(self, *args):
        r"""
        exceptions(self) -> std::ios_base::iostate
        exceptions(self, __except)

        Parameters
        ----------
        __except: std::ios_base::iostate

        """
        return _pyBasePython.ios_exceptions(self, *args)

    def __init__(self, __sb):
        r"""
        __init__(self, __sb) -> ios

        Parameters
        ----------
        __sb: std::basic_streambuf< char,std::char_traits< char > > *

        """
        _pyBasePython.ios_swiginit(self, _pyBasePython.new_ios(__sb))
    __swig_destroy__ = _pyBasePython.delete_ios

    def tie(self, *args):
        r"""
        tie(self) -> ostream
        tie(self, __tiestr) -> ostream

        Parameters
        ----------
        __tiestr: std::basic_ostream< char,std::char_traits< char > > *

        """
        return _pyBasePython.ios_tie(self, *args)

    def rdbuf(self, *args):
        r"""
        rdbuf(self) -> std::basic_streambuf< char,std::char_traits< char > >
        rdbuf(self, __sb) -> std::basic_streambuf< char,std::char_traits< char > > *

        Parameters
        ----------
        __sb: std::basic_streambuf< char,std::char_traits< char > > *

        """
        return _pyBasePython.ios_rdbuf(self, *args)

    def copyfmt(self, __rhs):
        r"""
        copyfmt(self, __rhs) -> ios

        Parameters
        ----------
        __rhs: std::basic_ios< char > const &

        """
        return _pyBasePython.ios_copyfmt(self, __rhs)

    def fill(self, *args):
        r"""
        fill(self) -> std::basic_ios< char >::char_type
        fill(self, __ch) -> std::basic_ios< char >::char_type

        Parameters
        ----------
        __ch: std::basic_ios< char >::char_type

        """
        return _pyBasePython.ios_fill(self, *args)

    def imbue(self, __loc):
        r"""
        imbue(self, __loc) -> std::locale

        Parameters
        ----------
        __loc: std::locale const &

        """
        return _pyBasePython.ios_imbue(self, __loc)

    def narrow(self, __c, __dfault):
        r"""
        narrow(self, __c, __dfault) -> char

        Parameters
        ----------
        __c: std::basic_ios< char >::char_type
        __dfault: char

        """
        return _pyBasePython.ios_narrow(self, __c, __dfault)

    def widen(self, __c):
        r"""
        widen(self, __c) -> std::basic_ios< char >::char_type

        Parameters
        ----------
        __c: char

        """
        return _pyBasePython.ios_widen(self, __c)

# Register ios in _pyBasePython:
_pyBasePython.ios_swigregister(ios)
class ostream(ios):
    r"""Proxy of C++ std::basic_ostream< char > class."""

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

    def __init__(self, __sb):
        r"""
        __init__(self, __sb) -> ostream

        Parameters
        ----------
        __sb: std::basic_streambuf< char,std::char_traits< char > > *

        """
        _pyBasePython.ostream_swiginit(self, _pyBasePython.new_ostream(__sb))
    __swig_destroy__ = _pyBasePython.delete_ostream

    def __lshift__(self, *args):
        r"""
        __lshift__(self, __pf) -> ostream

        Parameters
        ----------
        __pf: std::basic_ostream< char,std::char_traits< char > > &(*)(std::basic_ostream< char,std::char_traits< char > > &)

        __lshift__(self, __pf) -> ostream

        Parameters
        ----------
        __pf: std::basic_ios< char,std::char_traits< char > > &(*)(std::basic_ios< char,std::char_traits< char > > &)

        __lshift__(self, __pf) -> ostream

        Parameters
        ----------
        __pf: std::ios_base &(*)(std::ios_base &)

        __lshift__(self, __n) -> ostream

        Parameters
        ----------
        __n: long

        __lshift__(self, __n) -> ostream

        Parameters
        ----------
        __n: unsigned long

        __lshift__(self, __n) -> ostream

        Parameters
        ----------
        __n: bool

        __lshift__(self, __n) -> ostream

        Parameters
        ----------
        __n: short

        __lshift__(self, __n) -> ostream

        Parameters
        ----------
        __n: unsigned short

        __lshift__(self, __n) -> ostream

        Parameters
        ----------
        __n: int

        __lshift__(self, __n) -> ostream

        Parameters
        ----------
        __n: unsigned int

        __lshift__(self, __n) -> ostream

        Parameters
        ----------
        __n: long long

        __lshift__(self, __n) -> ostream

        Parameters
        ----------
        __n: unsigned long long

        __lshift__(self, __f) -> ostream

        Parameters
        ----------
        __f: double

        __lshift__(self, __f) -> ostream

        Parameters
        ----------
        __f: float

        __lshift__(self, __f) -> ostream

        Parameters
        ----------
        __f: long double

        __lshift__(self, __p) -> ostream

        Parameters
        ----------
        __p: void const *

        __lshift__(self, __sb) -> ostream

        Parameters
        ----------
        __sb: std::basic_streambuf< char,std::char_traits< char > > *

        __lshift__(self, s) -> ostream

        Parameters
        ----------
        s: std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &

        """
        return _pyBasePython.ostream___lshift__(self, *args)

    def put(self, __c):
        r"""
        put(self, __c) -> ostream

        Parameters
        ----------
        __c: std::basic_ostream< char >::char_type

        """
        return _pyBasePython.ostream_put(self, __c)

    def write(self, __s, __n):
        r"""
        write(self, __s, __n) -> ostream

        Parameters
        ----------
        __s: std::basic_ostream< char >::char_type const *
        __n: std::streamsize

        """
        return _pyBasePython.ostream_write(self, __s, __n)

    def flush(self):
        r"""flush(self) -> ostream"""
        return _pyBasePython.ostream_flush(self)

    def tellp(self):
        r"""tellp(self) -> std::basic_ostream< char >::pos_type"""
        return _pyBasePython.ostream_tellp(self)

    def seekp(self, *args):
        r"""
        seekp(self, arg2) -> ostream

        Parameters
        ----------
        arg2: std::basic_ostream< char >::pos_type

        seekp(self, arg2, arg3) -> ostream

        Parameters
        ----------
        arg2: std::basic_ostream< char >::off_type
        arg3: std::ios_base::seekdir

        """
        return _pyBasePython.ostream_seekp(self, *args)

# Register ostream in _pyBasePython:
_pyBasePython.ostream_swigregister(ostream)
class istream(ios):
    r"""Proxy of C++ std::basic_istream< char > class."""

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

    def __init__(self, __sb):
        r"""
        __init__(self, __sb) -> istream

        Parameters
        ----------
        __sb: std::basic_streambuf< char,std::char_traits< char > > *

        """
        _pyBasePython.istream_swiginit(self, _pyBasePython.new_istream(__sb))
    __swig_destroy__ = _pyBasePython.delete_istream

    def __rshift__(self, *args):
        r"""
        __rshift__(self, __pf) -> istream

        Parameters
        ----------
        __pf: std::basic_istream< char,std::char_traits< char > > &(*)(std::basic_istream< char,std::char_traits< char > > &)

        __rshift__(self, __pf) -> istream

        Parameters
        ----------
        __pf: std::basic_ios< char,std::char_traits< char > > &(*)(std::basic_ios< char,std::char_traits< char > > &)

        __rshift__(self, __pf) -> istream

        Parameters
        ----------
        __pf: std::ios_base &(*)(std::ios_base &)

        __rshift__(self, __n) -> istream

        Parameters
        ----------
        __n: bool &

        __rshift__(self, __n) -> istream

        Parameters
        ----------
        __n: short &

        __rshift__(self, __n) -> istream

        Parameters
        ----------
        __n: unsigned short &

        __rshift__(self, __n) -> istream

        Parameters
        ----------
        __n: int &

        __rshift__(self, __n) -> istream

        Parameters
        ----------
        __n: unsigned int &

        __rshift__(self, __n) -> istream

        Parameters
        ----------
        __n: long &

        __rshift__(self, __n) -> istream

        Parameters
        ----------
        __n: unsigned long &

        __rshift__(self, __n) -> istream

        Parameters
        ----------
        __n: long long &

        __rshift__(self, __n) -> istream

        Parameters
        ----------
        __n: unsigned long long &

        __rshift__(self, __f) -> istream

        Parameters
        ----------
        __f: float &

        __rshift__(self, __f) -> istream

        Parameters
        ----------
        __f: double &

        __rshift__(self, __f) -> istream

        Parameters
        ----------
        __f: long double &

        __rshift__(self, __p) -> istream

        Parameters
        ----------
        __p: void *&

        __rshift__(self, __sb) -> istream

        Parameters
        ----------
        __sb: std::basic_streambuf< char,std::char_traits< char > > *

        """
        return _pyBasePython.istream___rshift__(self, *args)

    def gcount(self):
        r"""gcount(self) -> std::streamsize"""
        return _pyBasePython.istream_gcount(self)

    def get(self, *args):
        r"""
        get(self) -> std::basic_istream< char >::int_type
        get(self, __c) -> istream

        Parameters
        ----------
        __c: std::basic_istream< char >::char_type &

        get(self, __s, __n, __delim) -> istream

        Parameters
        ----------
        __s: std::basic_istream< char >::char_type *
        __n: std::streamsize
        __delim: std::basic_istream< char >::char_type

        get(self, __s, __n) -> istream

        Parameters
        ----------
        __s: std::basic_istream< char >::char_type *
        __n: std::streamsize

        get(self, __sb, __delim) -> istream

        Parameters
        ----------
        __sb: std::basic_streambuf< char,std::char_traits< char > > &
        __delim: std::basic_istream< char >::char_type

        get(self, __sb) -> istream

        Parameters
        ----------
        __sb: std::basic_streambuf< char,std::char_traits< char > > &

        """
        return _pyBasePython.istream_get(self, *args)

    def getline(self, *args):
        r"""
        getline(self, __s, __n, __delim) -> istream

        Parameters
        ----------
        __s: std::basic_istream< char >::char_type *
        __n: std::streamsize
        __delim: std::basic_istream< char >::char_type

        getline(self, __s, __n) -> istream

        Parameters
        ----------
        __s: std::basic_istream< char >::char_type *
        __n: std::streamsize

        """
        return _pyBasePython.istream_getline(self, *args)

    def ignore(self, *args):
        r"""
        ignore(self, __n=1, __delim=std::char_traits< char >::eof()) -> istream

        Parameters
        ----------
        __n: std::streamsize
        __delim: std::basic_istream< char >::int_type

        """
        return _pyBasePython.istream_ignore(self, *args)

    def peek(self):
        r"""peek(self) -> std::basic_istream< char >::int_type"""
        return _pyBasePython.istream_peek(self)

    def read(self, __s, __n):
        r"""
        read(self, __s, __n) -> istream

        Parameters
        ----------
        __s: std::basic_istream< char >::char_type *
        __n: std::streamsize

        """
        return _pyBasePython.istream_read(self, __s, __n)

    def readsome(self, __s, __n):
        r"""
        readsome(self, __s, __n) -> std::streamsize

        Parameters
        ----------
        __s: std::basic_istream< char >::char_type *
        __n: std::streamsize

        """
        return _pyBasePython.istream_readsome(self, __s, __n)

    def putback(self, __c):
        r"""
        putback(self, __c) -> istream

        Parameters
        ----------
        __c: std::basic_istream< char >::char_type

        """
        return _pyBasePython.istream_putback(self, __c)

    def unget(self):
        r"""unget(self) -> istream"""
        return _pyBasePython.istream_unget(self)

    def sync(self):
        r"""sync(self) -> int"""
        return _pyBasePython.istream_sync(self)

    def tellg(self):
        r"""tellg(self) -> std::basic_istream< char >::pos_type"""
        return _pyBasePython.istream_tellg(self)

    def seekg(self, *args):
        r"""
        seekg(self, arg2) -> istream

        Parameters
        ----------
        arg2: std::basic_istream< char >::pos_type

        seekg(self, arg2, arg3) -> istream

        Parameters
        ----------
        arg2: std::basic_istream< char >::off_type
        arg3: std::ios_base::seekdir

        """
        return _pyBasePython.istream_seekg(self, *args)

# Register istream in _pyBasePython:
_pyBasePython.istream_swigregister(istream)
class iostream(istream, ostream):
    r"""Proxy of C++ std::basic_iostream< char > class."""

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

    def __init__(self, __sb):
        r"""
        __init__(self, __sb) -> iostream

        Parameters
        ----------
        __sb: std::basic_streambuf< char,std::char_traits< char > > *

        """
        _pyBasePython.iostream_swiginit(self, _pyBasePython.new_iostream(__sb))
    __swig_destroy__ = _pyBasePython.delete_iostream

# Register iostream in _pyBasePython:
_pyBasePython.iostream_swigregister(iostream)
cin = cvar.cin
cout = cvar.cout
cerr = cvar.cerr
clog = cvar.clog

endl_cb_ptr = _pyBasePython.endl_cb_ptr

endl = _pyBasePython.endl
ends_cb_ptr = _pyBasePython.ends_cb_ptr

ends = _pyBasePython.ends
flush_cb_ptr = _pyBasePython.flush_cb_ptr

flush = _pyBasePython.flush

str = str

class mapULD(collections.abc.MutableMapping if _swig_python_version_info >= (3, 3) else collections.MutableMapping):
    r"""Proxy of C++ std::map< unsigned long,double > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapULD_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.mapULD___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.mapULD___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::map< unsigned long,double >::size_type"""
        return _pyBasePython.mapULD___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):
        r"""
        __getitem__(self, key) -> std::map< unsigned long,double >::mapped_type const &

        Parameters
        ----------
        key: std::map< unsigned long,double >::key_type const &

        """
        return _pyBasePython.mapULD___getitem__(self, key)

    def __delitem__(self, key):
        r"""
        __delitem__(self, key)

        Parameters
        ----------
        key: std::map< unsigned long,double >::key_type const &

        """
        return _pyBasePython.mapULD___delitem__(self, key)

    def has_key(self, key):
        r"""
        has_key(self, key) -> bool

        Parameters
        ----------
        key: std::map< unsigned long,double >::key_type const &

        """
        return _pyBasePython.mapULD_has_key(self, key)

    def keys(self):
        r"""keys(self) -> PyObject *"""
        return _pyBasePython.mapULD_keys(self)

    def values(self):
        r"""values(self) -> PyObject *"""
        return _pyBasePython.mapULD_values(self)

    def items(self):
        r"""items(self) -> PyObject *"""
        return _pyBasePython.mapULD_items(self)

    def __contains__(self, key):
        r"""
        __contains__(self, key) -> bool

        Parameters
        ----------
        key: std::map< unsigned long,double >::key_type const &

        """
        return _pyBasePython.mapULD___contains__(self, key)

    def key_iterator(self):
        r"""key_iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapULD_key_iterator(self)

    def value_iterator(self):
        r"""value_iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapULD_value_iterator(self)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, key)

        Parameters
        ----------
        key: std::map< unsigned long,double >::key_type const &

        __setitem__(self, key, x)

        Parameters
        ----------
        key: std::map< unsigned long,double >::key_type const &
        x: std::map< unsigned long,double >::mapped_type const &

        """
        return _pyBasePython.mapULD___setitem__(self, *args)

    def asdict(self):
        r"""asdict(self) -> PyObject *"""
        return _pyBasePython.mapULD_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(self, other) -> mapULD

        Parameters
        ----------
        other: std::less< unsigned long > const &

        __init__(self) -> mapULD
        __init__(self, other) -> mapULD

        Parameters
        ----------
        other: std::map< unsigned long,double > const &

        """
        _pyBasePython.mapULD_swiginit(self, _pyBasePython.new_mapULD(*args))

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.mapULD_empty(self)

    def size(self):
        r"""size(self) -> std::map< unsigned long,double >::size_type"""
        return _pyBasePython.mapULD_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::map< unsigned long,double > &

        """
        return _pyBasePython.mapULD_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::map< unsigned long,double >::iterator"""
        return _pyBasePython.mapULD_begin(self)

    def end(self):
        r"""end(self) -> std::map< unsigned long,double >::iterator"""
        return _pyBasePython.mapULD_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::map< unsigned long,double >::reverse_iterator"""
        return _pyBasePython.mapULD_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::map< unsigned long,double >::reverse_iterator"""
        return _pyBasePython.mapULD_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.mapULD_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::map< unsigned long,double >::allocator_type"""
        return _pyBasePython.mapULD_get_allocator(self)

    def count(self, x):
        r"""
        count(self, x) -> std::map< unsigned long,double >::size_type

        Parameters
        ----------
        x: std::map< unsigned long,double >::key_type const &

        """
        return _pyBasePython.mapULD_count(self, x)

    def erase(self, *args):
        r"""
        erase(self, x) -> std::map< unsigned long,double >::size_type

        Parameters
        ----------
        x: std::map< unsigned long,double >::key_type const &

        erase(self, position)

        Parameters
        ----------
        position: std::map< unsigned long,double >::iterator

        erase(self, first, last)

        Parameters
        ----------
        first: std::map< unsigned long,double >::iterator
        last: std::map< unsigned long,double >::iterator

        """
        return _pyBasePython.mapULD_erase(self, *args)

    def find(self, x):
        r"""
        find(self, x) -> std::map< unsigned long,double >::iterator

        Parameters
        ----------
        x: std::map< unsigned long,double >::key_type const &

        """
        return _pyBasePython.mapULD_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(self, x) -> std::map< unsigned long,double >::iterator

        Parameters
        ----------
        x: std::map< unsigned long,double >::key_type const &

        """
        return _pyBasePython.mapULD_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(self, x) -> std::map< unsigned long,double >::iterator

        Parameters
        ----------
        x: std::map< unsigned long,double >::key_type const &

        """
        return _pyBasePython.mapULD_upper_bound(self, x)
    __swig_destroy__ = _pyBasePython.delete_mapULD

# Register mapULD in _pyBasePython:
_pyBasePython.mapULD_swigregister(mapULD)
class mapBB(collections.abc.MutableMapping if _swig_python_version_info >= (3, 3) else collections.MutableMapping):
    r"""Proxy of C++ std::map< bool,bool > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapBB_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.mapBB___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.mapBB___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::map< bool,bool >::size_type"""
        return _pyBasePython.mapBB___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):
        r"""
        __getitem__(self, key) -> std::map< bool,bool >::mapped_type const &

        Parameters
        ----------
        key: std::map< bool,bool >::key_type const &

        """
        return _pyBasePython.mapBB___getitem__(self, key)

    def __delitem__(self, key):
        r"""
        __delitem__(self, key)

        Parameters
        ----------
        key: std::map< bool,bool >::key_type const &

        """
        return _pyBasePython.mapBB___delitem__(self, key)

    def has_key(self, key):
        r"""
        has_key(self, key) -> bool

        Parameters
        ----------
        key: std::map< bool,bool >::key_type const &

        """
        return _pyBasePython.mapBB_has_key(self, key)

    def keys(self):
        r"""keys(self) -> PyObject *"""
        return _pyBasePython.mapBB_keys(self)

    def values(self):
        r"""values(self) -> PyObject *"""
        return _pyBasePython.mapBB_values(self)

    def items(self):
        r"""items(self) -> PyObject *"""
        return _pyBasePython.mapBB_items(self)

    def __contains__(self, key):
        r"""
        __contains__(self, key) -> bool

        Parameters
        ----------
        key: std::map< bool,bool >::key_type const &

        """
        return _pyBasePython.mapBB___contains__(self, key)

    def key_iterator(self):
        r"""key_iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapBB_key_iterator(self)

    def value_iterator(self):
        r"""value_iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapBB_value_iterator(self)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, key)

        Parameters
        ----------
        key: std::map< bool,bool >::key_type const &

        __setitem__(self, key, x)

        Parameters
        ----------
        key: std::map< bool,bool >::key_type const &
        x: std::map< bool,bool >::mapped_type const &

        """
        return _pyBasePython.mapBB___setitem__(self, *args)

    def asdict(self):
        r"""asdict(self) -> PyObject *"""
        return _pyBasePython.mapBB_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(self, other) -> mapBB

        Parameters
        ----------
        other: std::less< bool > const &

        __init__(self) -> mapBB
        __init__(self, other) -> mapBB

        Parameters
        ----------
        other: std::map< bool,bool > const &

        """
        _pyBasePython.mapBB_swiginit(self, _pyBasePython.new_mapBB(*args))

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.mapBB_empty(self)

    def size(self):
        r"""size(self) -> std::map< bool,bool >::size_type"""
        return _pyBasePython.mapBB_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::map< bool,bool > &

        """
        return _pyBasePython.mapBB_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::map< bool,bool >::iterator"""
        return _pyBasePython.mapBB_begin(self)

    def end(self):
        r"""end(self) -> std::map< bool,bool >::iterator"""
        return _pyBasePython.mapBB_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::map< bool,bool >::reverse_iterator"""
        return _pyBasePython.mapBB_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::map< bool,bool >::reverse_iterator"""
        return _pyBasePython.mapBB_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.mapBB_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::map< bool,bool >::allocator_type"""
        return _pyBasePython.mapBB_get_allocator(self)

    def count(self, x):
        r"""
        count(self, x) -> std::map< bool,bool >::size_type

        Parameters
        ----------
        x: std::map< bool,bool >::key_type const &

        """
        return _pyBasePython.mapBB_count(self, x)

    def erase(self, *args):
        r"""
        erase(self, x) -> std::map< bool,bool >::size_type

        Parameters
        ----------
        x: std::map< bool,bool >::key_type const &

        erase(self, position)

        Parameters
        ----------
        position: std::map< bool,bool >::iterator

        erase(self, first, last)

        Parameters
        ----------
        first: std::map< bool,bool >::iterator
        last: std::map< bool,bool >::iterator

        """
        return _pyBasePython.mapBB_erase(self, *args)

    def find(self, x):
        r"""
        find(self, x) -> std::map< bool,bool >::iterator

        Parameters
        ----------
        x: std::map< bool,bool >::key_type const &

        """
        return _pyBasePython.mapBB_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(self, x) -> std::map< bool,bool >::iterator

        Parameters
        ----------
        x: std::map< bool,bool >::key_type const &

        """
        return _pyBasePython.mapBB_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(self, x) -> std::map< bool,bool >::iterator

        Parameters
        ----------
        x: std::map< bool,bool >::key_type const &

        """
        return _pyBasePython.mapBB_upper_bound(self, x)
    __swig_destroy__ = _pyBasePython.delete_mapBB

# Register mapBB in _pyBasePython:
_pyBasePython.mapBB_swigregister(mapBB)
class mapII(collections.abc.MutableMapping if _swig_python_version_info >= (3, 3) else collections.MutableMapping):
    r"""Proxy of C++ std::map< int,int > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapII_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.mapII___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.mapII___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::map< int,int >::size_type"""
        return _pyBasePython.mapII___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):
        r"""
        __getitem__(self, key) -> std::map< int,int >::mapped_type const &

        Parameters
        ----------
        key: std::map< int,int >::key_type const &

        """
        return _pyBasePython.mapII___getitem__(self, key)

    def __delitem__(self, key):
        r"""
        __delitem__(self, key)

        Parameters
        ----------
        key: std::map< int,int >::key_type const &

        """
        return _pyBasePython.mapII___delitem__(self, key)

    def has_key(self, key):
        r"""
        has_key(self, key) -> bool

        Parameters
        ----------
        key: std::map< int,int >::key_type const &

        """
        return _pyBasePython.mapII_has_key(self, key)

    def keys(self):
        r"""keys(self) -> PyObject *"""
        return _pyBasePython.mapII_keys(self)

    def values(self):
        r"""values(self) -> PyObject *"""
        return _pyBasePython.mapII_values(self)

    def items(self):
        r"""items(self) -> PyObject *"""
        return _pyBasePython.mapII_items(self)

    def __contains__(self, key):
        r"""
        __contains__(self, key) -> bool

        Parameters
        ----------
        key: std::map< int,int >::key_type const &

        """
        return _pyBasePython.mapII___contains__(self, key)

    def key_iterator(self):
        r"""key_iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapII_key_iterator(self)

    def value_iterator(self):
        r"""value_iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapII_value_iterator(self)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, key)

        Parameters
        ----------
        key: std::map< int,int >::key_type const &

        __setitem__(self, key, x)

        Parameters
        ----------
        key: std::map< int,int >::key_type const &
        x: std::map< int,int >::mapped_type const &

        """
        return _pyBasePython.mapII___setitem__(self, *args)

    def asdict(self):
        r"""asdict(self) -> PyObject *"""
        return _pyBasePython.mapII_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(self, other) -> mapII

        Parameters
        ----------
        other: std::less< int > const &

        __init__(self) -> mapII
        __init__(self, other) -> mapII

        Parameters
        ----------
        other: std::map< int,int > const &

        """
        _pyBasePython.mapII_swiginit(self, _pyBasePython.new_mapII(*args))

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.mapII_empty(self)

    def size(self):
        r"""size(self) -> std::map< int,int >::size_type"""
        return _pyBasePython.mapII_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::map< int,int > &

        """
        return _pyBasePython.mapII_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::map< int,int >::iterator"""
        return _pyBasePython.mapII_begin(self)

    def end(self):
        r"""end(self) -> std::map< int,int >::iterator"""
        return _pyBasePython.mapII_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::map< int,int >::reverse_iterator"""
        return _pyBasePython.mapII_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::map< int,int >::reverse_iterator"""
        return _pyBasePython.mapII_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.mapII_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::map< int,int >::allocator_type"""
        return _pyBasePython.mapII_get_allocator(self)

    def count(self, x):
        r"""
        count(self, x) -> std::map< int,int >::size_type

        Parameters
        ----------
        x: std::map< int,int >::key_type const &

        """
        return _pyBasePython.mapII_count(self, x)

    def erase(self, *args):
        r"""
        erase(self, x) -> std::map< int,int >::size_type

        Parameters
        ----------
        x: std::map< int,int >::key_type const &

        erase(self, position)

        Parameters
        ----------
        position: std::map< int,int >::iterator

        erase(self, first, last)

        Parameters
        ----------
        first: std::map< int,int >::iterator
        last: std::map< int,int >::iterator

        """
        return _pyBasePython.mapII_erase(self, *args)

    def find(self, x):
        r"""
        find(self, x) -> std::map< int,int >::iterator

        Parameters
        ----------
        x: std::map< int,int >::key_type const &

        """
        return _pyBasePython.mapII_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(self, x) -> std::map< int,int >::iterator

        Parameters
        ----------
        x: std::map< int,int >::key_type const &

        """
        return _pyBasePython.mapII_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(self, x) -> std::map< int,int >::iterator

        Parameters
        ----------
        x: std::map< int,int >::key_type const &

        """
        return _pyBasePython.mapII_upper_bound(self, x)
    __swig_destroy__ = _pyBasePython.delete_mapII

# Register mapII in _pyBasePython:
_pyBasePython.mapII_swigregister(mapII)
class mapUCUC(collections.abc.MutableMapping if _swig_python_version_info >= (3, 3) else collections.MutableMapping):
    r"""Proxy of C++ std::map< unsigned char,unsigned char > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapUCUC_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.mapUCUC___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.mapUCUC___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::map< unsigned char,unsigned char >::size_type"""
        return _pyBasePython.mapUCUC___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):
        r"""
        __getitem__(self, key) -> std::map< unsigned char,unsigned char >::mapped_type const &

        Parameters
        ----------
        key: std::map< unsigned char,unsigned char >::key_type const &

        """
        return _pyBasePython.mapUCUC___getitem__(self, key)

    def __delitem__(self, key):
        r"""
        __delitem__(self, key)

        Parameters
        ----------
        key: std::map< unsigned char,unsigned char >::key_type const &

        """
        return _pyBasePython.mapUCUC___delitem__(self, key)

    def has_key(self, key):
        r"""
        has_key(self, key) -> bool

        Parameters
        ----------
        key: std::map< unsigned char,unsigned char >::key_type const &

        """
        return _pyBasePython.mapUCUC_has_key(self, key)

    def keys(self):
        r"""keys(self) -> PyObject *"""
        return _pyBasePython.mapUCUC_keys(self)

    def values(self):
        r"""values(self) -> PyObject *"""
        return _pyBasePython.mapUCUC_values(self)

    def items(self):
        r"""items(self) -> PyObject *"""
        return _pyBasePython.mapUCUC_items(self)

    def __contains__(self, key):
        r"""
        __contains__(self, key) -> bool

        Parameters
        ----------
        key: std::map< unsigned char,unsigned char >::key_type const &

        """
        return _pyBasePython.mapUCUC___contains__(self, key)

    def key_iterator(self):
        r"""key_iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapUCUC_key_iterator(self)

    def value_iterator(self):
        r"""value_iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapUCUC_value_iterator(self)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, key)

        Parameters
        ----------
        key: std::map< unsigned char,unsigned char >::key_type const &

        __setitem__(self, key, x)

        Parameters
        ----------
        key: std::map< unsigned char,unsigned char >::key_type const &
        x: std::map< unsigned char,unsigned char >::mapped_type const &

        """
        return _pyBasePython.mapUCUC___setitem__(self, *args)

    def asdict(self):
        r"""asdict(self) -> PyObject *"""
        return _pyBasePython.mapUCUC_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(self, other) -> mapUCUC

        Parameters
        ----------
        other: std::less< unsigned char > const &

        __init__(self) -> mapUCUC
        __init__(self, other) -> mapUCUC

        Parameters
        ----------
        other: std::map< unsigned char,unsigned char > const &

        """
        _pyBasePython.mapUCUC_swiginit(self, _pyBasePython.new_mapUCUC(*args))

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.mapUCUC_empty(self)

    def size(self):
        r"""size(self) -> std::map< unsigned char,unsigned char >::size_type"""
        return _pyBasePython.mapUCUC_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::map< unsigned char,unsigned char > &

        """
        return _pyBasePython.mapUCUC_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::map< unsigned char,unsigned char >::iterator"""
        return _pyBasePython.mapUCUC_begin(self)

    def end(self):
        r"""end(self) -> std::map< unsigned char,unsigned char >::iterator"""
        return _pyBasePython.mapUCUC_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::map< unsigned char,unsigned char >::reverse_iterator"""
        return _pyBasePython.mapUCUC_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::map< unsigned char,unsigned char >::reverse_iterator"""
        return _pyBasePython.mapUCUC_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.mapUCUC_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::map< unsigned char,unsigned char >::allocator_type"""
        return _pyBasePython.mapUCUC_get_allocator(self)

    def count(self, x):
        r"""
        count(self, x) -> std::map< unsigned char,unsigned char >::size_type

        Parameters
        ----------
        x: std::map< unsigned char,unsigned char >::key_type const &

        """
        return _pyBasePython.mapUCUC_count(self, x)

    def erase(self, *args):
        r"""
        erase(self, x) -> std::map< unsigned char,unsigned char >::size_type

        Parameters
        ----------
        x: std::map< unsigned char,unsigned char >::key_type const &

        erase(self, position)

        Parameters
        ----------
        position: std::map< unsigned char,unsigned char >::iterator

        erase(self, first, last)

        Parameters
        ----------
        first: std::map< unsigned char,unsigned char >::iterator
        last: std::map< unsigned char,unsigned char >::iterator

        """
        return _pyBasePython.mapUCUC_erase(self, *args)

    def find(self, x):
        r"""
        find(self, x) -> std::map< unsigned char,unsigned char >::iterator

        Parameters
        ----------
        x: std::map< unsigned char,unsigned char >::key_type const &

        """
        return _pyBasePython.mapUCUC_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(self, x) -> std::map< unsigned char,unsigned char >::iterator

        Parameters
        ----------
        x: std::map< unsigned char,unsigned char >::key_type const &

        """
        return _pyBasePython.mapUCUC_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(self, x) -> std::map< unsigned char,unsigned char >::iterator

        Parameters
        ----------
        x: std::map< unsigned char,unsigned char >::key_type const &

        """
        return _pyBasePython.mapUCUC_upper_bound(self, x)
    __swig_destroy__ = _pyBasePython.delete_mapUCUC

# Register mapUCUC in _pyBasePython:
_pyBasePython.mapUCUC_swigregister(mapUCUC)
class mapUIUI(collections.abc.MutableMapping if _swig_python_version_info >= (3, 3) else collections.MutableMapping):
    r"""Proxy of C++ std::map< unsigned int,unsigned int > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapUIUI_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.mapUIUI___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.mapUIUI___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::map< unsigned int,unsigned int >::size_type"""
        return _pyBasePython.mapUIUI___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):
        r"""
        __getitem__(self, key) -> std::map< unsigned int,unsigned int >::mapped_type const &

        Parameters
        ----------
        key: std::map< unsigned int,unsigned int >::key_type const &

        """
        return _pyBasePython.mapUIUI___getitem__(self, key)

    def __delitem__(self, key):
        r"""
        __delitem__(self, key)

        Parameters
        ----------
        key: std::map< unsigned int,unsigned int >::key_type const &

        """
        return _pyBasePython.mapUIUI___delitem__(self, key)

    def has_key(self, key):
        r"""
        has_key(self, key) -> bool

        Parameters
        ----------
        key: std::map< unsigned int,unsigned int >::key_type const &

        """
        return _pyBasePython.mapUIUI_has_key(self, key)

    def keys(self):
        r"""keys(self) -> PyObject *"""
        return _pyBasePython.mapUIUI_keys(self)

    def values(self):
        r"""values(self) -> PyObject *"""
        return _pyBasePython.mapUIUI_values(self)

    def items(self):
        r"""items(self) -> PyObject *"""
        return _pyBasePython.mapUIUI_items(self)

    def __contains__(self, key):
        r"""
        __contains__(self, key) -> bool

        Parameters
        ----------
        key: std::map< unsigned int,unsigned int >::key_type const &

        """
        return _pyBasePython.mapUIUI___contains__(self, key)

    def key_iterator(self):
        r"""key_iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapUIUI_key_iterator(self)

    def value_iterator(self):
        r"""value_iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapUIUI_value_iterator(self)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, key)

        Parameters
        ----------
        key: std::map< unsigned int,unsigned int >::key_type const &

        __setitem__(self, key, x)

        Parameters
        ----------
        key: std::map< unsigned int,unsigned int >::key_type const &
        x: std::map< unsigned int,unsigned int >::mapped_type const &

        """
        return _pyBasePython.mapUIUI___setitem__(self, *args)

    def asdict(self):
        r"""asdict(self) -> PyObject *"""
        return _pyBasePython.mapUIUI_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(self, other) -> mapUIUI

        Parameters
        ----------
        other: std::less< unsigned int > const &

        __init__(self) -> mapUIUI
        __init__(self, other) -> mapUIUI

        Parameters
        ----------
        other: std::map< unsigned int,unsigned int > const &

        """
        _pyBasePython.mapUIUI_swiginit(self, _pyBasePython.new_mapUIUI(*args))

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.mapUIUI_empty(self)

    def size(self):
        r"""size(self) -> std::map< unsigned int,unsigned int >::size_type"""
        return _pyBasePython.mapUIUI_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::map< unsigned int,unsigned int > &

        """
        return _pyBasePython.mapUIUI_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::map< unsigned int,unsigned int >::iterator"""
        return _pyBasePython.mapUIUI_begin(self)

    def end(self):
        r"""end(self) -> std::map< unsigned int,unsigned int >::iterator"""
        return _pyBasePython.mapUIUI_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::map< unsigned int,unsigned int >::reverse_iterator"""
        return _pyBasePython.mapUIUI_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::map< unsigned int,unsigned int >::reverse_iterator"""
        return _pyBasePython.mapUIUI_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.mapUIUI_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::map< unsigned int,unsigned int >::allocator_type"""
        return _pyBasePython.mapUIUI_get_allocator(self)

    def count(self, x):
        r"""
        count(self, x) -> std::map< unsigned int,unsigned int >::size_type

        Parameters
        ----------
        x: std::map< unsigned int,unsigned int >::key_type const &

        """
        return _pyBasePython.mapUIUI_count(self, x)

    def erase(self, *args):
        r"""
        erase(self, x) -> std::map< unsigned int,unsigned int >::size_type

        Parameters
        ----------
        x: std::map< unsigned int,unsigned int >::key_type const &

        erase(self, position)

        Parameters
        ----------
        position: std::map< unsigned int,unsigned int >::iterator

        erase(self, first, last)

        Parameters
        ----------
        first: std::map< unsigned int,unsigned int >::iterator
        last: std::map< unsigned int,unsigned int >::iterator

        """
        return _pyBasePython.mapUIUI_erase(self, *args)

    def find(self, x):
        r"""
        find(self, x) -> std::map< unsigned int,unsigned int >::iterator

        Parameters
        ----------
        x: std::map< unsigned int,unsigned int >::key_type const &

        """
        return _pyBasePython.mapUIUI_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(self, x) -> std::map< unsigned int,unsigned int >::iterator

        Parameters
        ----------
        x: std::map< unsigned int,unsigned int >::key_type const &

        """
        return _pyBasePython.mapUIUI_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(self, x) -> std::map< unsigned int,unsigned int >::iterator

        Parameters
        ----------
        x: std::map< unsigned int,unsigned int >::key_type const &

        """
        return _pyBasePython.mapUIUI_upper_bound(self, x)
    __swig_destroy__ = _pyBasePython.delete_mapUIUI

# Register mapUIUI in _pyBasePython:
_pyBasePython.mapUIUI_swigregister(mapUIUI)
class mapUSUS(collections.abc.MutableMapping if _swig_python_version_info >= (3, 3) else collections.MutableMapping):
    r"""Proxy of C++ std::map< unsigned short,unsigned short > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapUSUS_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.mapUSUS___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.mapUSUS___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::map< unsigned short,unsigned short >::size_type"""
        return _pyBasePython.mapUSUS___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):
        r"""
        __getitem__(self, key) -> std::map< unsigned short,unsigned short >::mapped_type const &

        Parameters
        ----------
        key: std::map< unsigned short,unsigned short >::key_type const &

        """
        return _pyBasePython.mapUSUS___getitem__(self, key)

    def __delitem__(self, key):
        r"""
        __delitem__(self, key)

        Parameters
        ----------
        key: std::map< unsigned short,unsigned short >::key_type const &

        """
        return _pyBasePython.mapUSUS___delitem__(self, key)

    def has_key(self, key):
        r"""
        has_key(self, key) -> bool

        Parameters
        ----------
        key: std::map< unsigned short,unsigned short >::key_type const &

        """
        return _pyBasePython.mapUSUS_has_key(self, key)

    def keys(self):
        r"""keys(self) -> PyObject *"""
        return _pyBasePython.mapUSUS_keys(self)

    def values(self):
        r"""values(self) -> PyObject *"""
        return _pyBasePython.mapUSUS_values(self)

    def items(self):
        r"""items(self) -> PyObject *"""
        return _pyBasePython.mapUSUS_items(self)

    def __contains__(self, key):
        r"""
        __contains__(self, key) -> bool

        Parameters
        ----------
        key: std::map< unsigned short,unsigned short >::key_type const &

        """
        return _pyBasePython.mapUSUS___contains__(self, key)

    def key_iterator(self):
        r"""key_iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapUSUS_key_iterator(self)

    def value_iterator(self):
        r"""value_iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapUSUS_value_iterator(self)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, key)

        Parameters
        ----------
        key: std::map< unsigned short,unsigned short >::key_type const &

        __setitem__(self, key, x)

        Parameters
        ----------
        key: std::map< unsigned short,unsigned short >::key_type const &
        x: std::map< unsigned short,unsigned short >::mapped_type const &

        """
        return _pyBasePython.mapUSUS___setitem__(self, *args)

    def asdict(self):
        r"""asdict(self) -> PyObject *"""
        return _pyBasePython.mapUSUS_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(self, other) -> mapUSUS

        Parameters
        ----------
        other: std::less< unsigned short > const &

        __init__(self) -> mapUSUS
        __init__(self, other) -> mapUSUS

        Parameters
        ----------
        other: std::map< unsigned short,unsigned short > const &

        """
        _pyBasePython.mapUSUS_swiginit(self, _pyBasePython.new_mapUSUS(*args))

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.mapUSUS_empty(self)

    def size(self):
        r"""size(self) -> std::map< unsigned short,unsigned short >::size_type"""
        return _pyBasePython.mapUSUS_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::map< unsigned short,unsigned short > &

        """
        return _pyBasePython.mapUSUS_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::map< unsigned short,unsigned short >::iterator"""
        return _pyBasePython.mapUSUS_begin(self)

    def end(self):
        r"""end(self) -> std::map< unsigned short,unsigned short >::iterator"""
        return _pyBasePython.mapUSUS_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::map< unsigned short,unsigned short >::reverse_iterator"""
        return _pyBasePython.mapUSUS_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::map< unsigned short,unsigned short >::reverse_iterator"""
        return _pyBasePython.mapUSUS_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.mapUSUS_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::map< unsigned short,unsigned short >::allocator_type"""
        return _pyBasePython.mapUSUS_get_allocator(self)

    def count(self, x):
        r"""
        count(self, x) -> std::map< unsigned short,unsigned short >::size_type

        Parameters
        ----------
        x: std::map< unsigned short,unsigned short >::key_type const &

        """
        return _pyBasePython.mapUSUS_count(self, x)

    def erase(self, *args):
        r"""
        erase(self, x) -> std::map< unsigned short,unsigned short >::size_type

        Parameters
        ----------
        x: std::map< unsigned short,unsigned short >::key_type const &

        erase(self, position)

        Parameters
        ----------
        position: std::map< unsigned short,unsigned short >::iterator

        erase(self, first, last)

        Parameters
        ----------
        first: std::map< unsigned short,unsigned short >::iterator
        last: std::map< unsigned short,unsigned short >::iterator

        """
        return _pyBasePython.mapUSUS_erase(self, *args)

    def find(self, x):
        r"""
        find(self, x) -> std::map< unsigned short,unsigned short >::iterator

        Parameters
        ----------
        x: std::map< unsigned short,unsigned short >::key_type const &

        """
        return _pyBasePython.mapUSUS_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(self, x) -> std::map< unsigned short,unsigned short >::iterator

        Parameters
        ----------
        x: std::map< unsigned short,unsigned short >::key_type const &

        """
        return _pyBasePython.mapUSUS_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(self, x) -> std::map< unsigned short,unsigned short >::iterator

        Parameters
        ----------
        x: std::map< unsigned short,unsigned short >::key_type const &

        """
        return _pyBasePython.mapUSUS_upper_bound(self, x)
    __swig_destroy__ = _pyBasePython.delete_mapUSUS

# Register mapUSUS in _pyBasePython:
_pyBasePython.mapUSUS_swigregister(mapUSUS)
class mapULUL(collections.abc.MutableMapping if _swig_python_version_info >= (3, 3) else collections.MutableMapping):
    r"""Proxy of C++ std::map< unsigned long,unsigned long > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapULUL_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.mapULUL___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.mapULUL___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::map< unsigned long,unsigned long >::size_type"""
        return _pyBasePython.mapULUL___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):
        r"""
        __getitem__(self, key) -> std::map< unsigned long,unsigned long >::mapped_type const &

        Parameters
        ----------
        key: std::map< unsigned long,unsigned long >::key_type const &

        """
        return _pyBasePython.mapULUL___getitem__(self, key)

    def __delitem__(self, key):
        r"""
        __delitem__(self, key)

        Parameters
        ----------
        key: std::map< unsigned long,unsigned long >::key_type const &

        """
        return _pyBasePython.mapULUL___delitem__(self, key)

    def has_key(self, key):
        r"""
        has_key(self, key) -> bool

        Parameters
        ----------
        key: std::map< unsigned long,unsigned long >::key_type const &

        """
        return _pyBasePython.mapULUL_has_key(self, key)

    def keys(self):
        r"""keys(self) -> PyObject *"""
        return _pyBasePython.mapULUL_keys(self)

    def values(self):
        r"""values(self) -> PyObject *"""
        return _pyBasePython.mapULUL_values(self)

    def items(self):
        r"""items(self) -> PyObject *"""
        return _pyBasePython.mapULUL_items(self)

    def __contains__(self, key):
        r"""
        __contains__(self, key) -> bool

        Parameters
        ----------
        key: std::map< unsigned long,unsigned long >::key_type const &

        """
        return _pyBasePython.mapULUL___contains__(self, key)

    def key_iterator(self):
        r"""key_iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapULUL_key_iterator(self)

    def value_iterator(self):
        r"""value_iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapULUL_value_iterator(self)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, key)

        Parameters
        ----------
        key: std::map< unsigned long,unsigned long >::key_type const &

        __setitem__(self, key, x)

        Parameters
        ----------
        key: std::map< unsigned long,unsigned long >::key_type const &
        x: std::map< unsigned long,unsigned long >::mapped_type const &

        """
        return _pyBasePython.mapULUL___setitem__(self, *args)

    def asdict(self):
        r"""asdict(self) -> PyObject *"""
        return _pyBasePython.mapULUL_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(self, other) -> mapULUL

        Parameters
        ----------
        other: std::less< unsigned long > const &

        __init__(self) -> mapULUL
        __init__(self, other) -> mapULUL

        Parameters
        ----------
        other: std::map< unsigned long,unsigned long > const &

        """
        _pyBasePython.mapULUL_swiginit(self, _pyBasePython.new_mapULUL(*args))

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.mapULUL_empty(self)

    def size(self):
        r"""size(self) -> std::map< unsigned long,unsigned long >::size_type"""
        return _pyBasePython.mapULUL_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::map< unsigned long,unsigned long > &

        """
        return _pyBasePython.mapULUL_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::map< unsigned long,unsigned long >::iterator"""
        return _pyBasePython.mapULUL_begin(self)

    def end(self):
        r"""end(self) -> std::map< unsigned long,unsigned long >::iterator"""
        return _pyBasePython.mapULUL_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::map< unsigned long,unsigned long >::reverse_iterator"""
        return _pyBasePython.mapULUL_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::map< unsigned long,unsigned long >::reverse_iterator"""
        return _pyBasePython.mapULUL_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.mapULUL_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::map< unsigned long,unsigned long >::allocator_type"""
        return _pyBasePython.mapULUL_get_allocator(self)

    def count(self, x):
        r"""
        count(self, x) -> std::map< unsigned long,unsigned long >::size_type

        Parameters
        ----------
        x: std::map< unsigned long,unsigned long >::key_type const &

        """
        return _pyBasePython.mapULUL_count(self, x)

    def erase(self, *args):
        r"""
        erase(self, x) -> std::map< unsigned long,unsigned long >::size_type

        Parameters
        ----------
        x: std::map< unsigned long,unsigned long >::key_type const &

        erase(self, position)

        Parameters
        ----------
        position: std::map< unsigned long,unsigned long >::iterator

        erase(self, first, last)

        Parameters
        ----------
        first: std::map< unsigned long,unsigned long >::iterator
        last: std::map< unsigned long,unsigned long >::iterator

        """
        return _pyBasePython.mapULUL_erase(self, *args)

    def find(self, x):
        r"""
        find(self, x) -> std::map< unsigned long,unsigned long >::iterator

        Parameters
        ----------
        x: std::map< unsigned long,unsigned long >::key_type const &

        """
        return _pyBasePython.mapULUL_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(self, x) -> std::map< unsigned long,unsigned long >::iterator

        Parameters
        ----------
        x: std::map< unsigned long,unsigned long >::key_type const &

        """
        return _pyBasePython.mapULUL_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(self, x) -> std::map< unsigned long,unsigned long >::iterator

        Parameters
        ----------
        x: std::map< unsigned long,unsigned long >::key_type const &

        """
        return _pyBasePython.mapULUL_upper_bound(self, x)
    __swig_destroy__ = _pyBasePython.delete_mapULUL

# Register mapULUL in _pyBasePython:
_pyBasePython.mapULUL_swigregister(mapULUL)
class mapSCSC(collections.abc.MutableMapping if _swig_python_version_info >= (3, 3) else collections.MutableMapping):
    r"""Proxy of C++ std::map< signed char,signed char > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapSCSC_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.mapSCSC___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.mapSCSC___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::map< signed char,signed char >::size_type"""
        return _pyBasePython.mapSCSC___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):
        r"""
        __getitem__(self, key) -> std::map< signed char,signed char >::mapped_type const &

        Parameters
        ----------
        key: std::map< signed char,signed char >::key_type const &

        """
        return _pyBasePython.mapSCSC___getitem__(self, key)

    def __delitem__(self, key):
        r"""
        __delitem__(self, key)

        Parameters
        ----------
        key: std::map< signed char,signed char >::key_type const &

        """
        return _pyBasePython.mapSCSC___delitem__(self, key)

    def has_key(self, key):
        r"""
        has_key(self, key) -> bool

        Parameters
        ----------
        key: std::map< signed char,signed char >::key_type const &

        """
        return _pyBasePython.mapSCSC_has_key(self, key)

    def keys(self):
        r"""keys(self) -> PyObject *"""
        return _pyBasePython.mapSCSC_keys(self)

    def values(self):
        r"""values(self) -> PyObject *"""
        return _pyBasePython.mapSCSC_values(self)

    def items(self):
        r"""items(self) -> PyObject *"""
        return _pyBasePython.mapSCSC_items(self)

    def __contains__(self, key):
        r"""
        __contains__(self, key) -> bool

        Parameters
        ----------
        key: std::map< signed char,signed char >::key_type const &

        """
        return _pyBasePython.mapSCSC___contains__(self, key)

    def key_iterator(self):
        r"""key_iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapSCSC_key_iterator(self)

    def value_iterator(self):
        r"""value_iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapSCSC_value_iterator(self)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, key)

        Parameters
        ----------
        key: std::map< signed char,signed char >::key_type const &

        __setitem__(self, key, x)

        Parameters
        ----------
        key: std::map< signed char,signed char >::key_type const &
        x: std::map< signed char,signed char >::mapped_type const &

        """
        return _pyBasePython.mapSCSC___setitem__(self, *args)

    def asdict(self):
        r"""asdict(self) -> PyObject *"""
        return _pyBasePython.mapSCSC_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(self, other) -> mapSCSC

        Parameters
        ----------
        other: std::less< signed char > const &

        __init__(self) -> mapSCSC
        __init__(self, other) -> mapSCSC

        Parameters
        ----------
        other: std::map< signed char,signed char > const &

        """
        _pyBasePython.mapSCSC_swiginit(self, _pyBasePython.new_mapSCSC(*args))

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.mapSCSC_empty(self)

    def size(self):
        r"""size(self) -> std::map< signed char,signed char >::size_type"""
        return _pyBasePython.mapSCSC_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::map< signed char,signed char > &

        """
        return _pyBasePython.mapSCSC_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::map< signed char,signed char >::iterator"""
        return _pyBasePython.mapSCSC_begin(self)

    def end(self):
        r"""end(self) -> std::map< signed char,signed char >::iterator"""
        return _pyBasePython.mapSCSC_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::map< signed char,signed char >::reverse_iterator"""
        return _pyBasePython.mapSCSC_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::map< signed char,signed char >::reverse_iterator"""
        return _pyBasePython.mapSCSC_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.mapSCSC_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::map< signed char,signed char >::allocator_type"""
        return _pyBasePython.mapSCSC_get_allocator(self)

    def count(self, x):
        r"""
        count(self, x) -> std::map< signed char,signed char >::size_type

        Parameters
        ----------
        x: std::map< signed char,signed char >::key_type const &

        """
        return _pyBasePython.mapSCSC_count(self, x)

    def erase(self, *args):
        r"""
        erase(self, x) -> std::map< signed char,signed char >::size_type

        Parameters
        ----------
        x: std::map< signed char,signed char >::key_type const &

        erase(self, position)

        Parameters
        ----------
        position: std::map< signed char,signed char >::iterator

        erase(self, first, last)

        Parameters
        ----------
        first: std::map< signed char,signed char >::iterator
        last: std::map< signed char,signed char >::iterator

        """
        return _pyBasePython.mapSCSC_erase(self, *args)

    def find(self, x):
        r"""
        find(self, x) -> std::map< signed char,signed char >::iterator

        Parameters
        ----------
        x: std::map< signed char,signed char >::key_type const &

        """
        return _pyBasePython.mapSCSC_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(self, x) -> std::map< signed char,signed char >::iterator

        Parameters
        ----------
        x: std::map< signed char,signed char >::key_type const &

        """
        return _pyBasePython.mapSCSC_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(self, x) -> std::map< signed char,signed char >::iterator

        Parameters
        ----------
        x: std::map< signed char,signed char >::key_type const &

        """
        return _pyBasePython.mapSCSC_upper_bound(self, x)
    __swig_destroy__ = _pyBasePython.delete_mapSCSC

# Register mapSCSC in _pyBasePython:
_pyBasePython.mapSCSC_swigregister(mapSCSC)
class mapSSSS(collections.abc.MutableMapping if _swig_python_version_info >= (3, 3) else collections.MutableMapping):
    r"""Proxy of C++ std::map< short,short > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapSSSS_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.mapSSSS___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.mapSSSS___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::map< short,short >::size_type"""
        return _pyBasePython.mapSSSS___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):
        r"""
        __getitem__(self, key) -> std::map< short,short >::mapped_type const &

        Parameters
        ----------
        key: std::map< short,short >::key_type const &

        """
        return _pyBasePython.mapSSSS___getitem__(self, key)

    def __delitem__(self, key):
        r"""
        __delitem__(self, key)

        Parameters
        ----------
        key: std::map< short,short >::key_type const &

        """
        return _pyBasePython.mapSSSS___delitem__(self, key)

    def has_key(self, key):
        r"""
        has_key(self, key) -> bool

        Parameters
        ----------
        key: std::map< short,short >::key_type const &

        """
        return _pyBasePython.mapSSSS_has_key(self, key)

    def keys(self):
        r"""keys(self) -> PyObject *"""
        return _pyBasePython.mapSSSS_keys(self)

    def values(self):
        r"""values(self) -> PyObject *"""
        return _pyBasePython.mapSSSS_values(self)

    def items(self):
        r"""items(self) -> PyObject *"""
        return _pyBasePython.mapSSSS_items(self)

    def __contains__(self, key):
        r"""
        __contains__(self, key) -> bool

        Parameters
        ----------
        key: std::map< short,short >::key_type const &

        """
        return _pyBasePython.mapSSSS___contains__(self, key)

    def key_iterator(self):
        r"""key_iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapSSSS_key_iterator(self)

    def value_iterator(self):
        r"""value_iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapSSSS_value_iterator(self)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, key)

        Parameters
        ----------
        key: std::map< short,short >::key_type const &

        __setitem__(self, key, x)

        Parameters
        ----------
        key: std::map< short,short >::key_type const &
        x: std::map< short,short >::mapped_type const &

        """
        return _pyBasePython.mapSSSS___setitem__(self, *args)

    def asdict(self):
        r"""asdict(self) -> PyObject *"""
        return _pyBasePython.mapSSSS_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(self, other) -> mapSSSS

        Parameters
        ----------
        other: std::less< short > const &

        __init__(self) -> mapSSSS
        __init__(self, other) -> mapSSSS

        Parameters
        ----------
        other: std::map< short,short > const &

        """
        _pyBasePython.mapSSSS_swiginit(self, _pyBasePython.new_mapSSSS(*args))

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.mapSSSS_empty(self)

    def size(self):
        r"""size(self) -> std::map< short,short >::size_type"""
        return _pyBasePython.mapSSSS_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::map< short,short > &

        """
        return _pyBasePython.mapSSSS_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::map< short,short >::iterator"""
        return _pyBasePython.mapSSSS_begin(self)

    def end(self):
        r"""end(self) -> std::map< short,short >::iterator"""
        return _pyBasePython.mapSSSS_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::map< short,short >::reverse_iterator"""
        return _pyBasePython.mapSSSS_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::map< short,short >::reverse_iterator"""
        return _pyBasePython.mapSSSS_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.mapSSSS_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::map< short,short >::allocator_type"""
        return _pyBasePython.mapSSSS_get_allocator(self)

    def count(self, x):
        r"""
        count(self, x) -> std::map< short,short >::size_type

        Parameters
        ----------
        x: std::map< short,short >::key_type const &

        """
        return _pyBasePython.mapSSSS_count(self, x)

    def erase(self, *args):
        r"""
        erase(self, x) -> std::map< short,short >::size_type

        Parameters
        ----------
        x: std::map< short,short >::key_type const &

        erase(self, position)

        Parameters
        ----------
        position: std::map< short,short >::iterator

        erase(self, first, last)

        Parameters
        ----------
        first: std::map< short,short >::iterator
        last: std::map< short,short >::iterator

        """
        return _pyBasePython.mapSSSS_erase(self, *args)

    def find(self, x):
        r"""
        find(self, x) -> std::map< short,short >::iterator

        Parameters
        ----------
        x: std::map< short,short >::key_type const &

        """
        return _pyBasePython.mapSSSS_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(self, x) -> std::map< short,short >::iterator

        Parameters
        ----------
        x: std::map< short,short >::key_type const &

        """
        return _pyBasePython.mapSSSS_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(self, x) -> std::map< short,short >::iterator

        Parameters
        ----------
        x: std::map< short,short >::key_type const &

        """
        return _pyBasePython.mapSSSS_upper_bound(self, x)
    __swig_destroy__ = _pyBasePython.delete_mapSSSS

# Register mapSSSS in _pyBasePython:
_pyBasePython.mapSSSS_swigregister(mapSSSS)
class mapSLSL(collections.abc.MutableMapping if _swig_python_version_info >= (3, 3) else collections.MutableMapping):
    r"""Proxy of C++ std::map< long,long > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapSLSL_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.mapSLSL___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.mapSLSL___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::map< long,long >::size_type"""
        return _pyBasePython.mapSLSL___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):
        r"""
        __getitem__(self, key) -> std::map< long,long >::mapped_type const &

        Parameters
        ----------
        key: std::map< long,long >::key_type const &

        """
        return _pyBasePython.mapSLSL___getitem__(self, key)

    def __delitem__(self, key):
        r"""
        __delitem__(self, key)

        Parameters
        ----------
        key: std::map< long,long >::key_type const &

        """
        return _pyBasePython.mapSLSL___delitem__(self, key)

    def has_key(self, key):
        r"""
        has_key(self, key) -> bool

        Parameters
        ----------
        key: std::map< long,long >::key_type const &

        """
        return _pyBasePython.mapSLSL_has_key(self, key)

    def keys(self):
        r"""keys(self) -> PyObject *"""
        return _pyBasePython.mapSLSL_keys(self)

    def values(self):
        r"""values(self) -> PyObject *"""
        return _pyBasePython.mapSLSL_values(self)

    def items(self):
        r"""items(self) -> PyObject *"""
        return _pyBasePython.mapSLSL_items(self)

    def __contains__(self, key):
        r"""
        __contains__(self, key) -> bool

        Parameters
        ----------
        key: std::map< long,long >::key_type const &

        """
        return _pyBasePython.mapSLSL___contains__(self, key)

    def key_iterator(self):
        r"""key_iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapSLSL_key_iterator(self)

    def value_iterator(self):
        r"""value_iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapSLSL_value_iterator(self)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, key)

        Parameters
        ----------
        key: std::map< long,long >::key_type const &

        __setitem__(self, key, x)

        Parameters
        ----------
        key: std::map< long,long >::key_type const &
        x: std::map< long,long >::mapped_type const &

        """
        return _pyBasePython.mapSLSL___setitem__(self, *args)

    def asdict(self):
        r"""asdict(self) -> PyObject *"""
        return _pyBasePython.mapSLSL_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(self, other) -> mapSLSL

        Parameters
        ----------
        other: std::less< long > const &

        __init__(self) -> mapSLSL
        __init__(self, other) -> mapSLSL

        Parameters
        ----------
        other: std::map< long,long > const &

        """
        _pyBasePython.mapSLSL_swiginit(self, _pyBasePython.new_mapSLSL(*args))

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.mapSLSL_empty(self)

    def size(self):
        r"""size(self) -> std::map< long,long >::size_type"""
        return _pyBasePython.mapSLSL_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::map< long,long > &

        """
        return _pyBasePython.mapSLSL_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::map< long,long >::iterator"""
        return _pyBasePython.mapSLSL_begin(self)

    def end(self):
        r"""end(self) -> std::map< long,long >::iterator"""
        return _pyBasePython.mapSLSL_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::map< long,long >::reverse_iterator"""
        return _pyBasePython.mapSLSL_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::map< long,long >::reverse_iterator"""
        return _pyBasePython.mapSLSL_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.mapSLSL_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::map< long,long >::allocator_type"""
        return _pyBasePython.mapSLSL_get_allocator(self)

    def count(self, x):
        r"""
        count(self, x) -> std::map< long,long >::size_type

        Parameters
        ----------
        x: std::map< long,long >::key_type const &

        """
        return _pyBasePython.mapSLSL_count(self, x)

    def erase(self, *args):
        r"""
        erase(self, x) -> std::map< long,long >::size_type

        Parameters
        ----------
        x: std::map< long,long >::key_type const &

        erase(self, position)

        Parameters
        ----------
        position: std::map< long,long >::iterator

        erase(self, first, last)

        Parameters
        ----------
        first: std::map< long,long >::iterator
        last: std::map< long,long >::iterator

        """
        return _pyBasePython.mapSLSL_erase(self, *args)

    def find(self, x):
        r"""
        find(self, x) -> std::map< long,long >::iterator

        Parameters
        ----------
        x: std::map< long,long >::key_type const &

        """
        return _pyBasePython.mapSLSL_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(self, x) -> std::map< long,long >::iterator

        Parameters
        ----------
        x: std::map< long,long >::key_type const &

        """
        return _pyBasePython.mapSLSL_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(self, x) -> std::map< long,long >::iterator

        Parameters
        ----------
        x: std::map< long,long >::key_type const &

        """
        return _pyBasePython.mapSLSL_upper_bound(self, x)
    __swig_destroy__ = _pyBasePython.delete_mapSLSL

# Register mapSLSL in _pyBasePython:
_pyBasePython.mapSLSL_swigregister(mapSLSL)
class mapFF(collections.abc.MutableMapping if _swig_python_version_info >= (3, 3) else collections.MutableMapping):
    r"""Proxy of C++ std::map< float,float > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapFF_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.mapFF___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.mapFF___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::map< float,float >::size_type"""
        return _pyBasePython.mapFF___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):
        r"""
        __getitem__(self, key) -> std::map< float,float >::mapped_type const &

        Parameters
        ----------
        key: std::map< float,float >::key_type const &

        """
        return _pyBasePython.mapFF___getitem__(self, key)

    def __delitem__(self, key):
        r"""
        __delitem__(self, key)

        Parameters
        ----------
        key: std::map< float,float >::key_type const &

        """
        return _pyBasePython.mapFF___delitem__(self, key)

    def has_key(self, key):
        r"""
        has_key(self, key) -> bool

        Parameters
        ----------
        key: std::map< float,float >::key_type const &

        """
        return _pyBasePython.mapFF_has_key(self, key)

    def keys(self):
        r"""keys(self) -> PyObject *"""
        return _pyBasePython.mapFF_keys(self)

    def values(self):
        r"""values(self) -> PyObject *"""
        return _pyBasePython.mapFF_values(self)

    def items(self):
        r"""items(self) -> PyObject *"""
        return _pyBasePython.mapFF_items(self)

    def __contains__(self, key):
        r"""
        __contains__(self, key) -> bool

        Parameters
        ----------
        key: std::map< float,float >::key_type const &

        """
        return _pyBasePython.mapFF___contains__(self, key)

    def key_iterator(self):
        r"""key_iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapFF_key_iterator(self)

    def value_iterator(self):
        r"""value_iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapFF_value_iterator(self)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, key)

        Parameters
        ----------
        key: std::map< float,float >::key_type const &

        __setitem__(self, key, x)

        Parameters
        ----------
        key: std::map< float,float >::key_type const &
        x: std::map< float,float >::mapped_type const &

        """
        return _pyBasePython.mapFF___setitem__(self, *args)

    def asdict(self):
        r"""asdict(self) -> PyObject *"""
        return _pyBasePython.mapFF_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(self, other) -> mapFF

        Parameters
        ----------
        other: std::less< float > const &

        __init__(self) -> mapFF
        __init__(self, other) -> mapFF

        Parameters
        ----------
        other: std::map< float,float > const &

        """
        _pyBasePython.mapFF_swiginit(self, _pyBasePython.new_mapFF(*args))

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.mapFF_empty(self)

    def size(self):
        r"""size(self) -> std::map< float,float >::size_type"""
        return _pyBasePython.mapFF_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::map< float,float > &

        """
        return _pyBasePython.mapFF_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::map< float,float >::iterator"""
        return _pyBasePython.mapFF_begin(self)

    def end(self):
        r"""end(self) -> std::map< float,float >::iterator"""
        return _pyBasePython.mapFF_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::map< float,float >::reverse_iterator"""
        return _pyBasePython.mapFF_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::map< float,float >::reverse_iterator"""
        return _pyBasePython.mapFF_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.mapFF_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::map< float,float >::allocator_type"""
        return _pyBasePython.mapFF_get_allocator(self)

    def count(self, x):
        r"""
        count(self, x) -> std::map< float,float >::size_type

        Parameters
        ----------
        x: std::map< float,float >::key_type const &

        """
        return _pyBasePython.mapFF_count(self, x)

    def erase(self, *args):
        r"""
        erase(self, x) -> std::map< float,float >::size_type

        Parameters
        ----------
        x: std::map< float,float >::key_type const &

        erase(self, position)

        Parameters
        ----------
        position: std::map< float,float >::iterator

        erase(self, first, last)

        Parameters
        ----------
        first: std::map< float,float >::iterator
        last: std::map< float,float >::iterator

        """
        return _pyBasePython.mapFF_erase(self, *args)

    def find(self, x):
        r"""
        find(self, x) -> std::map< float,float >::iterator

        Parameters
        ----------
        x: std::map< float,float >::key_type const &

        """
        return _pyBasePython.mapFF_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(self, x) -> std::map< float,float >::iterator

        Parameters
        ----------
        x: std::map< float,float >::key_type const &

        """
        return _pyBasePython.mapFF_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(self, x) -> std::map< float,float >::iterator

        Parameters
        ----------
        x: std::map< float,float >::key_type const &

        """
        return _pyBasePython.mapFF_upper_bound(self, x)
    __swig_destroy__ = _pyBasePython.delete_mapFF

# Register mapFF in _pyBasePython:
_pyBasePython.mapFF_swigregister(mapFF)
class mapDD(collections.abc.MutableMapping if _swig_python_version_info >= (3, 3) else collections.MutableMapping):
    r"""Proxy of C++ std::map< double,double > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapDD_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.mapDD___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.mapDD___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::map< double,double >::size_type"""
        return _pyBasePython.mapDD___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):
        r"""
        __getitem__(self, key) -> std::map< double,double >::mapped_type const &

        Parameters
        ----------
        key: std::map< double,double >::key_type const &

        """
        return _pyBasePython.mapDD___getitem__(self, key)

    def __delitem__(self, key):
        r"""
        __delitem__(self, key)

        Parameters
        ----------
        key: std::map< double,double >::key_type const &

        """
        return _pyBasePython.mapDD___delitem__(self, key)

    def has_key(self, key):
        r"""
        has_key(self, key) -> bool

        Parameters
        ----------
        key: std::map< double,double >::key_type const &

        """
        return _pyBasePython.mapDD_has_key(self, key)

    def keys(self):
        r"""keys(self) -> PyObject *"""
        return _pyBasePython.mapDD_keys(self)

    def values(self):
        r"""values(self) -> PyObject *"""
        return _pyBasePython.mapDD_values(self)

    def items(self):
        r"""items(self) -> PyObject *"""
        return _pyBasePython.mapDD_items(self)

    def __contains__(self, key):
        r"""
        __contains__(self, key) -> bool

        Parameters
        ----------
        key: std::map< double,double >::key_type const &

        """
        return _pyBasePython.mapDD___contains__(self, key)

    def key_iterator(self):
        r"""key_iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapDD_key_iterator(self)

    def value_iterator(self):
        r"""value_iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapDD_value_iterator(self)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, key)

        Parameters
        ----------
        key: std::map< double,double >::key_type const &

        __setitem__(self, key, x)

        Parameters
        ----------
        key: std::map< double,double >::key_type const &
        x: std::map< double,double >::mapped_type const &

        """
        return _pyBasePython.mapDD___setitem__(self, *args)

    def asdict(self):
        r"""asdict(self) -> PyObject *"""
        return _pyBasePython.mapDD_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(self, other) -> mapDD

        Parameters
        ----------
        other: std::less< double > const &

        __init__(self) -> mapDD
        __init__(self, other) -> mapDD

        Parameters
        ----------
        other: std::map< double,double > const &

        """
        _pyBasePython.mapDD_swiginit(self, _pyBasePython.new_mapDD(*args))

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.mapDD_empty(self)

    def size(self):
        r"""size(self) -> std::map< double,double >::size_type"""
        return _pyBasePython.mapDD_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::map< double,double > &

        """
        return _pyBasePython.mapDD_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::map< double,double >::iterator"""
        return _pyBasePython.mapDD_begin(self)

    def end(self):
        r"""end(self) -> std::map< double,double >::iterator"""
        return _pyBasePython.mapDD_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::map< double,double >::reverse_iterator"""
        return _pyBasePython.mapDD_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::map< double,double >::reverse_iterator"""
        return _pyBasePython.mapDD_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.mapDD_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::map< double,double >::allocator_type"""
        return _pyBasePython.mapDD_get_allocator(self)

    def count(self, x):
        r"""
        count(self, x) -> std::map< double,double >::size_type

        Parameters
        ----------
        x: std::map< double,double >::key_type const &

        """
        return _pyBasePython.mapDD_count(self, x)

    def erase(self, *args):
        r"""
        erase(self, x) -> std::map< double,double >::size_type

        Parameters
        ----------
        x: std::map< double,double >::key_type const &

        erase(self, position)

        Parameters
        ----------
        position: std::map< double,double >::iterator

        erase(self, first, last)

        Parameters
        ----------
        first: std::map< double,double >::iterator
        last: std::map< double,double >::iterator

        """
        return _pyBasePython.mapDD_erase(self, *args)

    def find(self, x):
        r"""
        find(self, x) -> std::map< double,double >::iterator

        Parameters
        ----------
        x: std::map< double,double >::key_type const &

        """
        return _pyBasePython.mapDD_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(self, x) -> std::map< double,double >::iterator

        Parameters
        ----------
        x: std::map< double,double >::key_type const &

        """
        return _pyBasePython.mapDD_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(self, x) -> std::map< double,double >::iterator

        Parameters
        ----------
        x: std::map< double,double >::key_type const &

        """
        return _pyBasePython.mapDD_upper_bound(self, x)
    __swig_destroy__ = _pyBasePython.delete_mapDD

# Register mapDD in _pyBasePython:
_pyBasePython.mapDD_swigregister(mapDD)
class pairI(object):
    r"""Proxy of C++ std::pair< int,int > class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> pairI
        __init__(self, first, second) -> pairI

        Parameters
        ----------
        first: int
        second: int

        __init__(self, other) -> pairI

        Parameters
        ----------
        other: std::pair< int,int > const &

        """
        _pyBasePython.pairI_swiginit(self, _pyBasePython.new_pairI(*args))
    first = property(_pyBasePython.pairI_first_get, _pyBasePython.pairI_first_set, doc=r"""first""")
    second = property(_pyBasePython.pairI_second_get, _pyBasePython.pairI_second_set, doc=r"""second""")
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _pyBasePython.delete_pairI

# Register pairI in _pyBasePython:
_pyBasePython.pairI_swigregister(pairI)
class pairUI(object):
    r"""Proxy of C++ std::pair< unsigned int,unsigned int > class."""

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

    def __init__(self, *args):
        r"""
        __init__(self) -> pairUI
        __init__(self, first, second) -> pairUI

        Parameters
        ----------
        first: unsigned int
        second: unsigned int

        __init__(self, other) -> pairUI

        Parameters
        ----------
        other: std::pair< unsigned int,unsigned int > const &

        """
        _pyBasePython.pairUI_swiginit(self, _pyBasePython.new_pairUI(*args))
    first = property(_pyBasePython.pairUI_first_get, _pyBasePython.pairUI_first_set, doc=r"""first""")
    second = property(_pyBasePython.pairUI_second_get, _pyBasePython.pairUI_second_set, doc=r"""second""")
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _pyBasePython.delete_pairUI

# Register pairUI in _pyBasePython:
_pyBasePython.pairUI_swigregister(pairUI)
class vectorB(object):
    r"""Proxy of C++ std::vector< bool > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.vectorB_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.vectorB___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.vectorB___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< bool >::size_type"""
        return _pyBasePython.vectorB___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectorB

        Parameters
        ----------
        i: std::vector< bool >::difference_type
        j: std::vector< bool >::difference_type

        """
        return _pyBasePython.vectorB___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< bool >::difference_type
        j: std::vector< bool >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< bool >::difference_type
        j: std::vector< bool >::difference_type
        v: std::vector< bool,std::allocator< bool > > const &

        """
        return _pyBasePython.vectorB___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< bool >::difference_type
        j: std::vector< bool >::difference_type

        """
        return _pyBasePython.vectorB___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< bool >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.vectorB___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectorB

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> std::vector< bool >::value_type

        Parameters
        ----------
        i: std::vector< bool >::difference_type

        """
        return _pyBasePython.vectorB___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< bool,std::allocator< bool > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< bool >::difference_type
        x: std::vector< bool >::value_type

        """
        return _pyBasePython.vectorB___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> std::vector< bool >::value_type"""
        return _pyBasePython.vectorB_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< bool >::value_type

        """
        return _pyBasePython.vectorB_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.vectorB_empty(self)

    def size(self):
        r"""size(self) -> std::vector< bool >::size_type"""
        return _pyBasePython.vectorB_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< bool > &

        """
        return _pyBasePython.vectorB_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< bool >::iterator"""
        return _pyBasePython.vectorB_begin(self)

    def end(self):
        r"""end(self) -> std::vector< bool >::iterator"""
        return _pyBasePython.vectorB_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< bool >::reverse_iterator"""
        return _pyBasePython.vectorB_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< bool >::reverse_iterator"""
        return _pyBasePython.vectorB_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.vectorB_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< bool >::allocator_type"""
        return _pyBasePython.vectorB_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.vectorB_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< bool >::iterator

        Parameters
        ----------
        pos: std::vector< bool >::iterator

        erase(self, first, last) -> std::vector< bool >::iterator

        Parameters
        ----------
        first: std::vector< bool >::iterator
        last: std::vector< bool >::iterator

        """
        return _pyBasePython.vectorB_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectorB
        __init__(self, other) -> vectorB

        Parameters
        ----------
        other: std::vector< bool > const &

        __init__(self, size) -> vectorB

        Parameters
        ----------
        size: std::vector< bool >::size_type

        __init__(self, size, value) -> vectorB

        Parameters
        ----------
        size: std::vector< bool >::size_type
        value: std::vector< bool >::value_type

        """
        _pyBasePython.vectorB_swiginit(self, _pyBasePython.new_vectorB(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< bool >::value_type

        """
        return _pyBasePython.vectorB_push_back(self, x)

    def front(self):
        r"""front(self) -> std::vector< bool >::value_type"""
        return _pyBasePython.vectorB_front(self)

    def back(self):
        r"""back(self) -> std::vector< bool >::value_type"""
        return _pyBasePython.vectorB_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< bool >::size_type
        x: std::vector< bool >::value_type

        """
        return _pyBasePython.vectorB_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< bool >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< bool >::size_type
        x: std::vector< bool >::value_type

        """
        return _pyBasePython.vectorB_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< bool >::iterator

        Parameters
        ----------
        pos: std::vector< bool >::iterator
        x: std::vector< bool >::value_type

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< bool >::iterator
        n: std::vector< bool >::size_type
        x: std::vector< bool >::value_type

        """
        return _pyBasePython.vectorB_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< bool >::size_type

        """
        return _pyBasePython.vectorB_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< bool >::size_type"""
        return _pyBasePython.vectorB_capacity(self)
    __swig_destroy__ = _pyBasePython.delete_vectorB

# Register vectorB in _pyBasePython:
_pyBasePython.vectorB_swigregister(vectorB)
class vectorvectorB(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< std::vector< bool > > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.vectorvectorB_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.vectorvectorB___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.vectorvectorB___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< std::vector< bool > >::size_type"""
        return _pyBasePython.vectorvectorB___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectorvectorB

        Parameters
        ----------
        i: std::vector< std::vector< bool > >::difference_type
        j: std::vector< std::vector< bool > >::difference_type

        """
        return _pyBasePython.vectorvectorB___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::vector< bool > >::difference_type
        j: std::vector< std::vector< bool > >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< std::vector< bool > >::difference_type
        j: std::vector< std::vector< bool > >::difference_type
        v: std::vector< std::vector< bool,std::allocator< bool > >,std::allocator< std::vector< bool,std::allocator< bool > > > > const &

        """
        return _pyBasePython.vectorvectorB___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::vector< bool > >::difference_type
        j: std::vector< std::vector< bool > >::difference_type

        """
        return _pyBasePython.vectorvectorB___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< std::vector< bool > >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.vectorvectorB___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectorvectorB

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> vectorB

        Parameters
        ----------
        i: std::vector< std::vector< bool > >::difference_type

        """
        return _pyBasePython.vectorvectorB___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< std::vector< bool,std::allocator< bool > >,std::allocator< std::vector< bool,std::allocator< bool > > > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< std::vector< bool > >::difference_type
        x: std::vector< std::vector< bool > >::value_type const &

        """
        return _pyBasePython.vectorvectorB___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> vectorB"""
        return _pyBasePython.vectorvectorB_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< std::vector< bool > >::value_type const &

        """
        return _pyBasePython.vectorvectorB_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.vectorvectorB_empty(self)

    def size(self):
        r"""size(self) -> std::vector< std::vector< bool > >::size_type"""
        return _pyBasePython.vectorvectorB_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< std::vector< bool,std::allocator< bool > > > &

        """
        return _pyBasePython.vectorvectorB_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< std::vector< bool > >::iterator"""
        return _pyBasePython.vectorvectorB_begin(self)

    def end(self):
        r"""end(self) -> std::vector< std::vector< bool > >::iterator"""
        return _pyBasePython.vectorvectorB_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< std::vector< bool > >::reverse_iterator"""
        return _pyBasePython.vectorvectorB_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< std::vector< bool > >::reverse_iterator"""
        return _pyBasePython.vectorvectorB_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.vectorvectorB_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< std::vector< bool > >::allocator_type"""
        return _pyBasePython.vectorvectorB_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.vectorvectorB_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< std::vector< bool > >::iterator

        Parameters
        ----------
        pos: std::vector< std::vector< bool > >::iterator

        erase(self, first, last) -> std::vector< std::vector< bool > >::iterator

        Parameters
        ----------
        first: std::vector< std::vector< bool > >::iterator
        last: std::vector< std::vector< bool > >::iterator

        """
        return _pyBasePython.vectorvectorB_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectorvectorB
        __init__(self, other) -> vectorvectorB

        Parameters
        ----------
        other: std::vector< std::vector< bool,std::allocator< bool > > > const &

        __init__(self, size) -> vectorvectorB

        Parameters
        ----------
        size: std::vector< std::vector< bool > >::size_type

        __init__(self, size, value) -> vectorvectorB

        Parameters
        ----------
        size: std::vector< std::vector< bool > >::size_type
        value: std::vector< std::vector< bool > >::value_type const &

        """
        _pyBasePython.vectorvectorB_swiginit(self, _pyBasePython.new_vectorvectorB(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< std::vector< bool > >::value_type const &

        """
        return _pyBasePython.vectorvectorB_push_back(self, x)

    def front(self):
        r"""front(self) -> vectorB"""
        return _pyBasePython.vectorvectorB_front(self)

    def back(self):
        r"""back(self) -> vectorB"""
        return _pyBasePython.vectorvectorB_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< std::vector< bool > >::size_type
        x: std::vector< std::vector< bool > >::value_type const &

        """
        return _pyBasePython.vectorvectorB_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< std::vector< bool > >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< std::vector< bool > >::size_type
        x: std::vector< std::vector< bool > >::value_type const &

        """
        return _pyBasePython.vectorvectorB_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< std::vector< bool > >::iterator

        Parameters
        ----------
        pos: std::vector< std::vector< bool > >::iterator
        x: std::vector< std::vector< bool > >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< std::vector< bool > >::iterator
        n: std::vector< std::vector< bool > >::size_type
        x: std::vector< std::vector< bool > >::value_type const &

        """
        return _pyBasePython.vectorvectorB_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< std::vector< bool > >::size_type

        """
        return _pyBasePython.vectorvectorB_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< std::vector< bool > >::size_type"""
        return _pyBasePython.vectorvectorB_capacity(self)
    __swig_destroy__ = _pyBasePython.delete_vectorvectorB

# Register vectorvectorB in _pyBasePython:
_pyBasePython.vectorvectorB_swigregister(vectorvectorB)
class vectorI(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< int > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.vectorI_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.vectorI___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.vectorI___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< int >::size_type"""
        return _pyBasePython.vectorI___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectorI

        Parameters
        ----------
        i: std::vector< int >::difference_type
        j: std::vector< int >::difference_type

        """
        return _pyBasePython.vectorI___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< int >::difference_type
        j: std::vector< int >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< int >::difference_type
        j: std::vector< int >::difference_type
        v: std::vector< int,std::allocator< int > > const &

        """
        return _pyBasePython.vectorI___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< int >::difference_type
        j: std::vector< int >::difference_type

        """
        return _pyBasePython.vectorI___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< int >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.vectorI___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectorI

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> std::vector< int >::value_type const &

        Parameters
        ----------
        i: std::vector< int >::difference_type

        """
        return _pyBasePython.vectorI___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< int,std::allocator< int > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< int >::difference_type
        x: std::vector< int >::value_type const &

        """
        return _pyBasePython.vectorI___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> std::vector< int >::value_type"""
        return _pyBasePython.vectorI_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< int >::value_type const &

        """
        return _pyBasePython.vectorI_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.vectorI_empty(self)

    def size(self):
        r"""size(self) -> std::vector< int >::size_type"""
        return _pyBasePython.vectorI_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< int > &

        """
        return _pyBasePython.vectorI_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< int >::iterator"""
        return _pyBasePython.vectorI_begin(self)

    def end(self):
        r"""end(self) -> std::vector< int >::iterator"""
        return _pyBasePython.vectorI_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< int >::reverse_iterator"""
        return _pyBasePython.vectorI_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< int >::reverse_iterator"""
        return _pyBasePython.vectorI_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.vectorI_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< int >::allocator_type"""
        return _pyBasePython.vectorI_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.vectorI_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< int >::iterator

        Parameters
        ----------
        pos: std::vector< int >::iterator

        erase(self, first, last) -> std::vector< int >::iterator

        Parameters
        ----------
        first: std::vector< int >::iterator
        last: std::vector< int >::iterator

        """
        return _pyBasePython.vectorI_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectorI
        __init__(self, other) -> vectorI

        Parameters
        ----------
        other: std::vector< int > const &

        __init__(self, size) -> vectorI

        Parameters
        ----------
        size: std::vector< int >::size_type

        __init__(self, size, value) -> vectorI

        Parameters
        ----------
        size: std::vector< int >::size_type
        value: std::vector< int >::value_type const &

        """
        _pyBasePython.vectorI_swiginit(self, _pyBasePython.new_vectorI(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< int >::value_type const &

        """
        return _pyBasePython.vectorI_push_back(self, x)

    def front(self):
        r"""front(self) -> std::vector< int >::value_type const &"""
        return _pyBasePython.vectorI_front(self)

    def back(self):
        r"""back(self) -> std::vector< int >::value_type const &"""
        return _pyBasePython.vectorI_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< int >::size_type
        x: std::vector< int >::value_type const &

        """
        return _pyBasePython.vectorI_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< int >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< int >::size_type
        x: std::vector< int >::value_type const &

        """
        return _pyBasePython.vectorI_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< int >::iterator

        Parameters
        ----------
        pos: std::vector< int >::iterator
        x: std::vector< int >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< int >::iterator
        n: std::vector< int >::size_type
        x: std::vector< int >::value_type const &

        """
        return _pyBasePython.vectorI_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< int >::size_type

        """
        return _pyBasePython.vectorI_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< int >::size_type"""
        return _pyBasePython.vectorI_capacity(self)
    __swig_destroy__ = _pyBasePython.delete_vectorI

# Register vectorI in _pyBasePython:
_pyBasePython.vectorI_swigregister(vectorI)
class vectorvectorI(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< std::vector< int > > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.vectorvectorI_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.vectorvectorI___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.vectorvectorI___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< std::vector< int > >::size_type"""
        return _pyBasePython.vectorvectorI___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectorvectorI

        Parameters
        ----------
        i: std::vector< std::vector< int > >::difference_type
        j: std::vector< std::vector< int > >::difference_type

        """
        return _pyBasePython.vectorvectorI___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::vector< int > >::difference_type
        j: std::vector< std::vector< int > >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< std::vector< int > >::difference_type
        j: std::vector< std::vector< int > >::difference_type
        v: std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &

        """
        return _pyBasePython.vectorvectorI___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::vector< int > >::difference_type
        j: std::vector< std::vector< int > >::difference_type

        """
        return _pyBasePython.vectorvectorI___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< std::vector< int > >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.vectorvectorI___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectorvectorI

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> vectorI

        Parameters
        ----------
        i: std::vector< std::vector< int > >::difference_type

        """
        return _pyBasePython.vectorvectorI___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< std::vector< int > >::difference_type
        x: std::vector< std::vector< int > >::value_type const &

        """
        return _pyBasePython.vectorvectorI___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> vectorI"""
        return _pyBasePython.vectorvectorI_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< std::vector< int > >::value_type const &

        """
        return _pyBasePython.vectorvectorI_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.vectorvectorI_empty(self)

    def size(self):
        r"""size(self) -> std::vector< std::vector< int > >::size_type"""
        return _pyBasePython.vectorvectorI_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< std::vector< int,std::allocator< int > > > &

        """
        return _pyBasePython.vectorvectorI_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< std::vector< int > >::iterator"""
        return _pyBasePython.vectorvectorI_begin(self)

    def end(self):
        r"""end(self) -> std::vector< std::vector< int > >::iterator"""
        return _pyBasePython.vectorvectorI_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< std::vector< int > >::reverse_iterator"""
        return _pyBasePython.vectorvectorI_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< std::vector< int > >::reverse_iterator"""
        return _pyBasePython.vectorvectorI_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.vectorvectorI_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< std::vector< int > >::allocator_type"""
        return _pyBasePython.vectorvectorI_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.vectorvectorI_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< std::vector< int > >::iterator

        Parameters
        ----------
        pos: std::vector< std::vector< int > >::iterator

        erase(self, first, last) -> std::vector< std::vector< int > >::iterator

        Parameters
        ----------
        first: std::vector< std::vector< int > >::iterator
        last: std::vector< std::vector< int > >::iterator

        """
        return _pyBasePython.vectorvectorI_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectorvectorI
        __init__(self, other) -> vectorvectorI

        Parameters
        ----------
        other: std::vector< std::vector< int,std::allocator< int > > > const &

        __init__(self, size) -> vectorvectorI

        Parameters
        ----------
        size: std::vector< std::vector< int > >::size_type

        __init__(self, size, value) -> vectorvectorI

        Parameters
        ----------
        size: std::vector< std::vector< int > >::size_type
        value: std::vector< std::vector< int > >::value_type const &

        """
        _pyBasePython.vectorvectorI_swiginit(self, _pyBasePython.new_vectorvectorI(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< std::vector< int > >::value_type const &

        """
        return _pyBasePython.vectorvectorI_push_back(self, x)

    def front(self):
        r"""front(self) -> vectorI"""
        return _pyBasePython.vectorvectorI_front(self)

    def back(self):
        r"""back(self) -> vectorI"""
        return _pyBasePython.vectorvectorI_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< std::vector< int > >::size_type
        x: std::vector< std::vector< int > >::value_type const &

        """
        return _pyBasePython.vectorvectorI_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< std::vector< int > >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< std::vector< int > >::size_type
        x: std::vector< std::vector< int > >::value_type const &

        """
        return _pyBasePython.vectorvectorI_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< std::vector< int > >::iterator

        Parameters
        ----------
        pos: std::vector< std::vector< int > >::iterator
        x: std::vector< std::vector< int > >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< std::vector< int > >::iterator
        n: std::vector< std::vector< int > >::size_type
        x: std::vector< std::vector< int > >::value_type const &

        """
        return _pyBasePython.vectorvectorI_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< std::vector< int > >::size_type

        """
        return _pyBasePython.vectorvectorI_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< std::vector< int > >::size_type"""
        return _pyBasePython.vectorvectorI_capacity(self)
    __swig_destroy__ = _pyBasePython.delete_vectorvectorI

# Register vectorvectorI in _pyBasePython:
_pyBasePython.vectorvectorI_swigregister(vectorvectorI)
class vectorUC(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< unsigned char > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.vectorUC_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.vectorUC___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.vectorUC___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< unsigned char >::size_type"""
        return _pyBasePython.vectorUC___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectorUC

        Parameters
        ----------
        i: std::vector< unsigned char >::difference_type
        j: std::vector< unsigned char >::difference_type

        """
        return _pyBasePython.vectorUC___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< unsigned char >::difference_type
        j: std::vector< unsigned char >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< unsigned char >::difference_type
        j: std::vector< unsigned char >::difference_type
        v: std::vector< unsigned char,std::allocator< unsigned char > > const &

        """
        return _pyBasePython.vectorUC___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< unsigned char >::difference_type
        j: std::vector< unsigned char >::difference_type

        """
        return _pyBasePython.vectorUC___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< unsigned char >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.vectorUC___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectorUC

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> std::vector< unsigned char >::value_type const &

        Parameters
        ----------
        i: std::vector< unsigned char >::difference_type

        """
        return _pyBasePython.vectorUC___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< unsigned char,std::allocator< unsigned char > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< unsigned char >::difference_type
        x: std::vector< unsigned char >::value_type const &

        """
        return _pyBasePython.vectorUC___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> std::vector< unsigned char >::value_type"""
        return _pyBasePython.vectorUC_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< unsigned char >::value_type const &

        """
        return _pyBasePython.vectorUC_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.vectorUC_empty(self)

    def size(self):
        r"""size(self) -> std::vector< unsigned char >::size_type"""
        return _pyBasePython.vectorUC_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< unsigned char > &

        """
        return _pyBasePython.vectorUC_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< unsigned char >::iterator"""
        return _pyBasePython.vectorUC_begin(self)

    def end(self):
        r"""end(self) -> std::vector< unsigned char >::iterator"""
        return _pyBasePython.vectorUC_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< unsigned char >::reverse_iterator"""
        return _pyBasePython.vectorUC_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< unsigned char >::reverse_iterator"""
        return _pyBasePython.vectorUC_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.vectorUC_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< unsigned char >::allocator_type"""
        return _pyBasePython.vectorUC_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.vectorUC_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< unsigned char >::iterator

        Parameters
        ----------
        pos: std::vector< unsigned char >::iterator

        erase(self, first, last) -> std::vector< unsigned char >::iterator

        Parameters
        ----------
        first: std::vector< unsigned char >::iterator
        last: std::vector< unsigned char >::iterator

        """
        return _pyBasePython.vectorUC_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectorUC
        __init__(self, other) -> vectorUC

        Parameters
        ----------
        other: std::vector< unsigned char > const &

        __init__(self, size) -> vectorUC

        Parameters
        ----------
        size: std::vector< unsigned char >::size_type

        __init__(self, size, value) -> vectorUC

        Parameters
        ----------
        size: std::vector< unsigned char >::size_type
        value: std::vector< unsigned char >::value_type const &

        """
        _pyBasePython.vectorUC_swiginit(self, _pyBasePython.new_vectorUC(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< unsigned char >::value_type const &

        """
        return _pyBasePython.vectorUC_push_back(self, x)

    def front(self):
        r"""front(self) -> std::vector< unsigned char >::value_type const &"""
        return _pyBasePython.vectorUC_front(self)

    def back(self):
        r"""back(self) -> std::vector< unsigned char >::value_type const &"""
        return _pyBasePython.vectorUC_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< unsigned char >::size_type
        x: std::vector< unsigned char >::value_type const &

        """
        return _pyBasePython.vectorUC_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< unsigned char >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< unsigned char >::size_type
        x: std::vector< unsigned char >::value_type const &

        """
        return _pyBasePython.vectorUC_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< unsigned char >::iterator

        Parameters
        ----------
        pos: std::vector< unsigned char >::iterator
        x: std::vector< unsigned char >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< unsigned char >::iterator
        n: std::vector< unsigned char >::size_type
        x: std::vector< unsigned char >::value_type const &

        """
        return _pyBasePython.vectorUC_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< unsigned char >::size_type

        """
        return _pyBasePython.vectorUC_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< unsigned char >::size_type"""
        return _pyBasePython.vectorUC_capacity(self)
    __swig_destroy__ = _pyBasePython.delete_vectorUC

# Register vectorUC in _pyBasePython:
_pyBasePython.vectorUC_swigregister(vectorUC)
class vectorvectorUC(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< std::vector< unsigned char > > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.vectorvectorUC_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.vectorvectorUC___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.vectorvectorUC___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< std::vector< unsigned char > >::size_type"""
        return _pyBasePython.vectorvectorUC___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectorvectorUC

        Parameters
        ----------
        i: std::vector< std::vector< unsigned char > >::difference_type
        j: std::vector< std::vector< unsigned char > >::difference_type

        """
        return _pyBasePython.vectorvectorUC___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::vector< unsigned char > >::difference_type
        j: std::vector< std::vector< unsigned char > >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< std::vector< unsigned char > >::difference_type
        j: std::vector< std::vector< unsigned char > >::difference_type
        v: std::vector< std::vector< unsigned char,std::allocator< unsigned char > >,std::allocator< std::vector< unsigned char,std::allocator< unsigned char > > > > const &

        """
        return _pyBasePython.vectorvectorUC___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::vector< unsigned char > >::difference_type
        j: std::vector< std::vector< unsigned char > >::difference_type

        """
        return _pyBasePython.vectorvectorUC___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< std::vector< unsigned char > >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.vectorvectorUC___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectorvectorUC

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> vectorUC

        Parameters
        ----------
        i: std::vector< std::vector< unsigned char > >::difference_type

        """
        return _pyBasePython.vectorvectorUC___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< std::vector< unsigned char,std::allocator< unsigned char > >,std::allocator< std::vector< unsigned char,std::allocator< unsigned char > > > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< std::vector< unsigned char > >::difference_type
        x: std::vector< std::vector< unsigned char > >::value_type const &

        """
        return _pyBasePython.vectorvectorUC___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> vectorUC"""
        return _pyBasePython.vectorvectorUC_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< std::vector< unsigned char > >::value_type const &

        """
        return _pyBasePython.vectorvectorUC_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.vectorvectorUC_empty(self)

    def size(self):
        r"""size(self) -> std::vector< std::vector< unsigned char > >::size_type"""
        return _pyBasePython.vectorvectorUC_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< std::vector< unsigned char,std::allocator< unsigned char > > > &

        """
        return _pyBasePython.vectorvectorUC_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< std::vector< unsigned char > >::iterator"""
        return _pyBasePython.vectorvectorUC_begin(self)

    def end(self):
        r"""end(self) -> std::vector< std::vector< unsigned char > >::iterator"""
        return _pyBasePython.vectorvectorUC_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< std::vector< unsigned char > >::reverse_iterator"""
        return _pyBasePython.vectorvectorUC_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< std::vector< unsigned char > >::reverse_iterator"""
        return _pyBasePython.vectorvectorUC_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.vectorvectorUC_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< std::vector< unsigned char > >::allocator_type"""
        return _pyBasePython.vectorvectorUC_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.vectorvectorUC_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< std::vector< unsigned char > >::iterator

        Parameters
        ----------
        pos: std::vector< std::vector< unsigned char > >::iterator

        erase(self, first, last) -> std::vector< std::vector< unsigned char > >::iterator

        Parameters
        ----------
        first: std::vector< std::vector< unsigned char > >::iterator
        last: std::vector< std::vector< unsigned char > >::iterator

        """
        return _pyBasePython.vectorvectorUC_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectorvectorUC
        __init__(self, other) -> vectorvectorUC

        Parameters
        ----------
        other: std::vector< std::vector< unsigned char,std::allocator< unsigned char > > > const &

        __init__(self, size) -> vectorvectorUC

        Parameters
        ----------
        size: std::vector< std::vector< unsigned char > >::size_type

        __init__(self, size, value) -> vectorvectorUC

        Parameters
        ----------
        size: std::vector< std::vector< unsigned char > >::size_type
        value: std::vector< std::vector< unsigned char > >::value_type const &

        """
        _pyBasePython.vectorvectorUC_swiginit(self, _pyBasePython.new_vectorvectorUC(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< std::vector< unsigned char > >::value_type const &

        """
        return _pyBasePython.vectorvectorUC_push_back(self, x)

    def front(self):
        r"""front(self) -> vectorUC"""
        return _pyBasePython.vectorvectorUC_front(self)

    def back(self):
        r"""back(self) -> vectorUC"""
        return _pyBasePython.vectorvectorUC_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< std::vector< unsigned char > >::size_type
        x: std::vector< std::vector< unsigned char > >::value_type const &

        """
        return _pyBasePython.vectorvectorUC_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< std::vector< unsigned char > >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< std::vector< unsigned char > >::size_type
        x: std::vector< std::vector< unsigned char > >::value_type const &

        """
        return _pyBasePython.vectorvectorUC_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< std::vector< unsigned char > >::iterator

        Parameters
        ----------
        pos: std::vector< std::vector< unsigned char > >::iterator
        x: std::vector< std::vector< unsigned char > >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< std::vector< unsigned char > >::iterator
        n: std::vector< std::vector< unsigned char > >::size_type
        x: std::vector< std::vector< unsigned char > >::value_type const &

        """
        return _pyBasePython.vectorvectorUC_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< std::vector< unsigned char > >::size_type

        """
        return _pyBasePython.vectorvectorUC_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< std::vector< unsigned char > >::size_type"""
        return _pyBasePython.vectorvectorUC_capacity(self)
    __swig_destroy__ = _pyBasePython.delete_vectorvectorUC

# Register vectorvectorUC in _pyBasePython:
_pyBasePython.vectorvectorUC_swigregister(vectorvectorUC)
class vectorUS(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< unsigned short > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.vectorUS_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.vectorUS___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.vectorUS___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< unsigned short >::size_type"""
        return _pyBasePython.vectorUS___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectorUS

        Parameters
        ----------
        i: std::vector< unsigned short >::difference_type
        j: std::vector< unsigned short >::difference_type

        """
        return _pyBasePython.vectorUS___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< unsigned short >::difference_type
        j: std::vector< unsigned short >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< unsigned short >::difference_type
        j: std::vector< unsigned short >::difference_type
        v: std::vector< unsigned short,std::allocator< unsigned short > > const &

        """
        return _pyBasePython.vectorUS___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< unsigned short >::difference_type
        j: std::vector< unsigned short >::difference_type

        """
        return _pyBasePython.vectorUS___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< unsigned short >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.vectorUS___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectorUS

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> std::vector< unsigned short >::value_type const &

        Parameters
        ----------
        i: std::vector< unsigned short >::difference_type

        """
        return _pyBasePython.vectorUS___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< unsigned short,std::allocator< unsigned short > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< unsigned short >::difference_type
        x: std::vector< unsigned short >::value_type const &

        """
        return _pyBasePython.vectorUS___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> std::vector< unsigned short >::value_type"""
        return _pyBasePython.vectorUS_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< unsigned short >::value_type const &

        """
        return _pyBasePython.vectorUS_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.vectorUS_empty(self)

    def size(self):
        r"""size(self) -> std::vector< unsigned short >::size_type"""
        return _pyBasePython.vectorUS_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< unsigned short > &

        """
        return _pyBasePython.vectorUS_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< unsigned short >::iterator"""
        return _pyBasePython.vectorUS_begin(self)

    def end(self):
        r"""end(self) -> std::vector< unsigned short >::iterator"""
        return _pyBasePython.vectorUS_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< unsigned short >::reverse_iterator"""
        return _pyBasePython.vectorUS_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< unsigned short >::reverse_iterator"""
        return _pyBasePython.vectorUS_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.vectorUS_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< unsigned short >::allocator_type"""
        return _pyBasePython.vectorUS_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.vectorUS_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< unsigned short >::iterator

        Parameters
        ----------
        pos: std::vector< unsigned short >::iterator

        erase(self, first, last) -> std::vector< unsigned short >::iterator

        Parameters
        ----------
        first: std::vector< unsigned short >::iterator
        last: std::vector< unsigned short >::iterator

        """
        return _pyBasePython.vectorUS_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectorUS
        __init__(self, other) -> vectorUS

        Parameters
        ----------
        other: std::vector< unsigned short > const &

        __init__(self, size) -> vectorUS

        Parameters
        ----------
        size: std::vector< unsigned short >::size_type

        __init__(self, size, value) -> vectorUS

        Parameters
        ----------
        size: std::vector< unsigned short >::size_type
        value: std::vector< unsigned short >::value_type const &

        """
        _pyBasePython.vectorUS_swiginit(self, _pyBasePython.new_vectorUS(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< unsigned short >::value_type const &

        """
        return _pyBasePython.vectorUS_push_back(self, x)

    def front(self):
        r"""front(self) -> std::vector< unsigned short >::value_type const &"""
        return _pyBasePython.vectorUS_front(self)

    def back(self):
        r"""back(self) -> std::vector< unsigned short >::value_type const &"""
        return _pyBasePython.vectorUS_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< unsigned short >::size_type
        x: std::vector< unsigned short >::value_type const &

        """
        return _pyBasePython.vectorUS_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< unsigned short >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< unsigned short >::size_type
        x: std::vector< unsigned short >::value_type const &

        """
        return _pyBasePython.vectorUS_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< unsigned short >::iterator

        Parameters
        ----------
        pos: std::vector< unsigned short >::iterator
        x: std::vector< unsigned short >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< unsigned short >::iterator
        n: std::vector< unsigned short >::size_type
        x: std::vector< unsigned short >::value_type const &

        """
        return _pyBasePython.vectorUS_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< unsigned short >::size_type

        """
        return _pyBasePython.vectorUS_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< unsigned short >::size_type"""
        return _pyBasePython.vectorUS_capacity(self)
    __swig_destroy__ = _pyBasePython.delete_vectorUS

# Register vectorUS in _pyBasePython:
_pyBasePython.vectorUS_swigregister(vectorUS)
class vectorvectorUS(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< std::vector< unsigned short > > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.vectorvectorUS_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.vectorvectorUS___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.vectorvectorUS___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< std::vector< unsigned short > >::size_type"""
        return _pyBasePython.vectorvectorUS___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectorvectorUS

        Parameters
        ----------
        i: std::vector< std::vector< unsigned short > >::difference_type
        j: std::vector< std::vector< unsigned short > >::difference_type

        """
        return _pyBasePython.vectorvectorUS___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::vector< unsigned short > >::difference_type
        j: std::vector< std::vector< unsigned short > >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< std::vector< unsigned short > >::difference_type
        j: std::vector< std::vector< unsigned short > >::difference_type
        v: std::vector< std::vector< unsigned short,std::allocator< unsigned short > >,std::allocator< std::vector< unsigned short,std::allocator< unsigned short > > > > const &

        """
        return _pyBasePython.vectorvectorUS___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::vector< unsigned short > >::difference_type
        j: std::vector< std::vector< unsigned short > >::difference_type

        """
        return _pyBasePython.vectorvectorUS___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< std::vector< unsigned short > >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.vectorvectorUS___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectorvectorUS

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> vectorUS

        Parameters
        ----------
        i: std::vector< std::vector< unsigned short > >::difference_type

        """
        return _pyBasePython.vectorvectorUS___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< std::vector< unsigned short,std::allocator< unsigned short > >,std::allocator< std::vector< unsigned short,std::allocator< unsigned short > > > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< std::vector< unsigned short > >::difference_type
        x: std::vector< std::vector< unsigned short > >::value_type const &

        """
        return _pyBasePython.vectorvectorUS___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> vectorUS"""
        return _pyBasePython.vectorvectorUS_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< std::vector< unsigned short > >::value_type const &

        """
        return _pyBasePython.vectorvectorUS_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.vectorvectorUS_empty(self)

    def size(self):
        r"""size(self) -> std::vector< std::vector< unsigned short > >::size_type"""
        return _pyBasePython.vectorvectorUS_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< std::vector< unsigned short,std::allocator< unsigned short > > > &

        """
        return _pyBasePython.vectorvectorUS_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< std::vector< unsigned short > >::iterator"""
        return _pyBasePython.vectorvectorUS_begin(self)

    def end(self):
        r"""end(self) -> std::vector< std::vector< unsigned short > >::iterator"""
        return _pyBasePython.vectorvectorUS_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< std::vector< unsigned short > >::reverse_iterator"""
        return _pyBasePython.vectorvectorUS_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< std::vector< unsigned short > >::reverse_iterator"""
        return _pyBasePython.vectorvectorUS_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.vectorvectorUS_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< std::vector< unsigned short > >::allocator_type"""
        return _pyBasePython.vectorvectorUS_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.vectorvectorUS_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< std::vector< unsigned short > >::iterator

        Parameters
        ----------
        pos: std::vector< std::vector< unsigned short > >::iterator

        erase(self, first, last) -> std::vector< std::vector< unsigned short > >::iterator

        Parameters
        ----------
        first: std::vector< std::vector< unsigned short > >::iterator
        last: std::vector< std::vector< unsigned short > >::iterator

        """
        return _pyBasePython.vectorvectorUS_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectorvectorUS
        __init__(self, other) -> vectorvectorUS

        Parameters
        ----------
        other: std::vector< std::vector< unsigned short,std::allocator< unsigned short > > > const &

        __init__(self, size) -> vectorvectorUS

        Parameters
        ----------
        size: std::vector< std::vector< unsigned short > >::size_type

        __init__(self, size, value) -> vectorvectorUS

        Parameters
        ----------
        size: std::vector< std::vector< unsigned short > >::size_type
        value: std::vector< std::vector< unsigned short > >::value_type const &

        """
        _pyBasePython.vectorvectorUS_swiginit(self, _pyBasePython.new_vectorvectorUS(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< std::vector< unsigned short > >::value_type const &

        """
        return _pyBasePython.vectorvectorUS_push_back(self, x)

    def front(self):
        r"""front(self) -> vectorUS"""
        return _pyBasePython.vectorvectorUS_front(self)

    def back(self):
        r"""back(self) -> vectorUS"""
        return _pyBasePython.vectorvectorUS_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< std::vector< unsigned short > >::size_type
        x: std::vector< std::vector< unsigned short > >::value_type const &

        """
        return _pyBasePython.vectorvectorUS_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< std::vector< unsigned short > >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< std::vector< unsigned short > >::size_type
        x: std::vector< std::vector< unsigned short > >::value_type const &

        """
        return _pyBasePython.vectorvectorUS_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< std::vector< unsigned short > >::iterator

        Parameters
        ----------
        pos: std::vector< std::vector< unsigned short > >::iterator
        x: std::vector< std::vector< unsigned short > >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< std::vector< unsigned short > >::iterator
        n: std::vector< std::vector< unsigned short > >::size_type
        x: std::vector< std::vector< unsigned short > >::value_type const &

        """
        return _pyBasePython.vectorvectorUS_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< std::vector< unsigned short > >::size_type

        """
        return _pyBasePython.vectorvectorUS_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< std::vector< unsigned short > >::size_type"""
        return _pyBasePython.vectorvectorUS_capacity(self)
    __swig_destroy__ = _pyBasePython.delete_vectorvectorUS

# Register vectorvectorUS in _pyBasePython:
_pyBasePython.vectorvectorUS_swigregister(vectorvectorUS)
class vectorUI(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< unsigned int > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.vectorUI_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.vectorUI___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.vectorUI___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< unsigned int >::size_type"""
        return _pyBasePython.vectorUI___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectorUI

        Parameters
        ----------
        i: std::vector< unsigned int >::difference_type
        j: std::vector< unsigned int >::difference_type

        """
        return _pyBasePython.vectorUI___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< unsigned int >::difference_type
        j: std::vector< unsigned int >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< unsigned int >::difference_type
        j: std::vector< unsigned int >::difference_type
        v: std::vector< unsigned int,std::allocator< unsigned int > > const &

        """
        return _pyBasePython.vectorUI___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< unsigned int >::difference_type
        j: std::vector< unsigned int >::difference_type

        """
        return _pyBasePython.vectorUI___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< unsigned int >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.vectorUI___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectorUI

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> std::vector< unsigned int >::value_type const &

        Parameters
        ----------
        i: std::vector< unsigned int >::difference_type

        """
        return _pyBasePython.vectorUI___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< unsigned int,std::allocator< unsigned int > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< unsigned int >::difference_type
        x: std::vector< unsigned int >::value_type const &

        """
        return _pyBasePython.vectorUI___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> std::vector< unsigned int >::value_type"""
        return _pyBasePython.vectorUI_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< unsigned int >::value_type const &

        """
        return _pyBasePython.vectorUI_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.vectorUI_empty(self)

    def size(self):
        r"""size(self) -> std::vector< unsigned int >::size_type"""
        return _pyBasePython.vectorUI_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< unsigned int > &

        """
        return _pyBasePython.vectorUI_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< unsigned int >::iterator"""
        return _pyBasePython.vectorUI_begin(self)

    def end(self):
        r"""end(self) -> std::vector< unsigned int >::iterator"""
        return _pyBasePython.vectorUI_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< unsigned int >::reverse_iterator"""
        return _pyBasePython.vectorUI_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< unsigned int >::reverse_iterator"""
        return _pyBasePython.vectorUI_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.vectorUI_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< unsigned int >::allocator_type"""
        return _pyBasePython.vectorUI_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.vectorUI_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< unsigned int >::iterator

        Parameters
        ----------
        pos: std::vector< unsigned int >::iterator

        erase(self, first, last) -> std::vector< unsigned int >::iterator

        Parameters
        ----------
        first: std::vector< unsigned int >::iterator
        last: std::vector< unsigned int >::iterator

        """
        return _pyBasePython.vectorUI_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectorUI
        __init__(self, other) -> vectorUI

        Parameters
        ----------
        other: std::vector< unsigned int > const &

        __init__(self, size) -> vectorUI

        Parameters
        ----------
        size: std::vector< unsigned int >::size_type

        __init__(self, size, value) -> vectorUI

        Parameters
        ----------
        size: std::vector< unsigned int >::size_type
        value: std::vector< unsigned int >::value_type const &

        """
        _pyBasePython.vectorUI_swiginit(self, _pyBasePython.new_vectorUI(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< unsigned int >::value_type const &

        """
        return _pyBasePython.vectorUI_push_back(self, x)

    def front(self):
        r"""front(self) -> std::vector< unsigned int >::value_type const &"""
        return _pyBasePython.vectorUI_front(self)

    def back(self):
        r"""back(self) -> std::vector< unsigned int >::value_type const &"""
        return _pyBasePython.vectorUI_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< unsigned int >::size_type
        x: std::vector< unsigned int >::value_type const &

        """
        return _pyBasePython.vectorUI_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< unsigned int >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< unsigned int >::size_type
        x: std::vector< unsigned int >::value_type const &

        """
        return _pyBasePython.vectorUI_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< unsigned int >::iterator

        Parameters
        ----------
        pos: std::vector< unsigned int >::iterator
        x: std::vector< unsigned int >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< unsigned int >::iterator
        n: std::vector< unsigned int >::size_type
        x: std::vector< unsigned int >::value_type const &

        """
        return _pyBasePython.vectorUI_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< unsigned int >::size_type

        """
        return _pyBasePython.vectorUI_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< unsigned int >::size_type"""
        return _pyBasePython.vectorUI_capacity(self)
    __swig_destroy__ = _pyBasePython.delete_vectorUI

# Register vectorUI in _pyBasePython:
_pyBasePython.vectorUI_swigregister(vectorUI)
class vectorvectorUI(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< std::vector< unsigned int > > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.vectorvectorUI_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.vectorvectorUI___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.vectorvectorUI___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< std::vector< unsigned int > >::size_type"""
        return _pyBasePython.vectorvectorUI___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectorvectorUI

        Parameters
        ----------
        i: std::vector< std::vector< unsigned int > >::difference_type
        j: std::vector< std::vector< unsigned int > >::difference_type

        """
        return _pyBasePython.vectorvectorUI___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::vector< unsigned int > >::difference_type
        j: std::vector< std::vector< unsigned int > >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< std::vector< unsigned int > >::difference_type
        j: std::vector< std::vector< unsigned int > >::difference_type
        v: std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > const &

        """
        return _pyBasePython.vectorvectorUI___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::vector< unsigned int > >::difference_type
        j: std::vector< std::vector< unsigned int > >::difference_type

        """
        return _pyBasePython.vectorvectorUI___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< std::vector< unsigned int > >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.vectorvectorUI___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectorvectorUI

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> vectorUI

        Parameters
        ----------
        i: std::vector< std::vector< unsigned int > >::difference_type

        """
        return _pyBasePython.vectorvectorUI___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< std::vector< unsigned int > >::difference_type
        x: std::vector< std::vector< unsigned int > >::value_type const &

        """
        return _pyBasePython.vectorvectorUI___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> vectorUI"""
        return _pyBasePython.vectorvectorUI_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< std::vector< unsigned int > >::value_type const &

        """
        return _pyBasePython.vectorvectorUI_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.vectorvectorUI_empty(self)

    def size(self):
        r"""size(self) -> std::vector< std::vector< unsigned int > >::size_type"""
        return _pyBasePython.vectorvectorUI_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< std::vector< unsigned int,std::allocator< unsigned int > > > &

        """
        return _pyBasePython.vectorvectorUI_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< std::vector< unsigned int > >::iterator"""
        return _pyBasePython.vectorvectorUI_begin(self)

    def end(self):
        r"""end(self) -> std::vector< std::vector< unsigned int > >::iterator"""
        return _pyBasePython.vectorvectorUI_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< std::vector< unsigned int > >::reverse_iterator"""
        return _pyBasePython.vectorvectorUI_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< std::vector< unsigned int > >::reverse_iterator"""
        return _pyBasePython.vectorvectorUI_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.vectorvectorUI_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< std::vector< unsigned int > >::allocator_type"""
        return _pyBasePython.vectorvectorUI_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.vectorvectorUI_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< std::vector< unsigned int > >::iterator

        Parameters
        ----------
        pos: std::vector< std::vector< unsigned int > >::iterator

        erase(self, first, last) -> std::vector< std::vector< unsigned int > >::iterator

        Parameters
        ----------
        first: std::vector< std::vector< unsigned int > >::iterator
        last: std::vector< std::vector< unsigned int > >::iterator

        """
        return _pyBasePython.vectorvectorUI_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectorvectorUI
        __init__(self, other) -> vectorvectorUI

        Parameters
        ----------
        other: std::vector< std::vector< unsigned int,std::allocator< unsigned int > > > const &

        __init__(self, size) -> vectorvectorUI

        Parameters
        ----------
        size: std::vector< std::vector< unsigned int > >::size_type

        __init__(self, size, value) -> vectorvectorUI

        Parameters
        ----------
        size: std::vector< std::vector< unsigned int > >::size_type
        value: std::vector< std::vector< unsigned int > >::value_type const &

        """
        _pyBasePython.vectorvectorUI_swiginit(self, _pyBasePython.new_vectorvectorUI(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< std::vector< unsigned int > >::value_type const &

        """
        return _pyBasePython.vectorvectorUI_push_back(self, x)

    def front(self):
        r"""front(self) -> vectorUI"""
        return _pyBasePython.vectorvectorUI_front(self)

    def back(self):
        r"""back(self) -> vectorUI"""
        return _pyBasePython.vectorvectorUI_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< std::vector< unsigned int > >::size_type
        x: std::vector< std::vector< unsigned int > >::value_type const &

        """
        return _pyBasePython.vectorvectorUI_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< std::vector< unsigned int > >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< std::vector< unsigned int > >::size_type
        x: std::vector< std::vector< unsigned int > >::value_type const &

        """
        return _pyBasePython.vectorvectorUI_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< std::vector< unsigned int > >::iterator

        Parameters
        ----------
        pos: std::vector< std::vector< unsigned int > >::iterator
        x: std::vector< std::vector< unsigned int > >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< std::vector< unsigned int > >::iterator
        n: std::vector< std::vector< unsigned int > >::size_type
        x: std::vector< std::vector< unsigned int > >::value_type const &

        """
        return _pyBasePython.vectorvectorUI_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< std::vector< unsigned int > >::size_type

        """
        return _pyBasePython.vectorvectorUI_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< std::vector< unsigned int > >::size_type"""
        return _pyBasePython.vectorvectorUI_capacity(self)
    __swig_destroy__ = _pyBasePython.delete_vectorvectorUI

# Register vectorvectorUI in _pyBasePython:
_pyBasePython.vectorvectorUI_swigregister(vectorvectorUI)
class vectorUL(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< unsigned long > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.vectorUL_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.vectorUL___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.vectorUL___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< unsigned long >::size_type"""
        return _pyBasePython.vectorUL___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectorUL

        Parameters
        ----------
        i: std::vector< unsigned long >::difference_type
        j: std::vector< unsigned long >::difference_type

        """
        return _pyBasePython.vectorUL___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< unsigned long >::difference_type
        j: std::vector< unsigned long >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< unsigned long >::difference_type
        j: std::vector< unsigned long >::difference_type
        v: std::vector< unsigned long,std::allocator< unsigned long > > const &

        """
        return _pyBasePython.vectorUL___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< unsigned long >::difference_type
        j: std::vector< unsigned long >::difference_type

        """
        return _pyBasePython.vectorUL___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< unsigned long >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.vectorUL___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectorUL

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> std::vector< unsigned long >::value_type const &

        Parameters
        ----------
        i: std::vector< unsigned long >::difference_type

        """
        return _pyBasePython.vectorUL___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< unsigned long,std::allocator< unsigned long > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< unsigned long >::difference_type
        x: std::vector< unsigned long >::value_type const &

        """
        return _pyBasePython.vectorUL___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> std::vector< unsigned long >::value_type"""
        return _pyBasePython.vectorUL_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< unsigned long >::value_type const &

        """
        return _pyBasePython.vectorUL_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.vectorUL_empty(self)

    def size(self):
        r"""size(self) -> std::vector< unsigned long >::size_type"""
        return _pyBasePython.vectorUL_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< unsigned long > &

        """
        return _pyBasePython.vectorUL_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< unsigned long >::iterator"""
        return _pyBasePython.vectorUL_begin(self)

    def end(self):
        r"""end(self) -> std::vector< unsigned long >::iterator"""
        return _pyBasePython.vectorUL_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< unsigned long >::reverse_iterator"""
        return _pyBasePython.vectorUL_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< unsigned long >::reverse_iterator"""
        return _pyBasePython.vectorUL_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.vectorUL_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< unsigned long >::allocator_type"""
        return _pyBasePython.vectorUL_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.vectorUL_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< unsigned long >::iterator

        Parameters
        ----------
        pos: std::vector< unsigned long >::iterator

        erase(self, first, last) -> std::vector< unsigned long >::iterator

        Parameters
        ----------
        first: std::vector< unsigned long >::iterator
        last: std::vector< unsigned long >::iterator

        """
        return _pyBasePython.vectorUL_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectorUL
        __init__(self, other) -> vectorUL

        Parameters
        ----------
        other: std::vector< unsigned long > const &

        __init__(self, size) -> vectorUL

        Parameters
        ----------
        size: std::vector< unsigned long >::size_type

        __init__(self, size, value) -> vectorUL

        Parameters
        ----------
        size: std::vector< unsigned long >::size_type
        value: std::vector< unsigned long >::value_type const &

        """
        _pyBasePython.vectorUL_swiginit(self, _pyBasePython.new_vectorUL(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< unsigned long >::value_type const &

        """
        return _pyBasePython.vectorUL_push_back(self, x)

    def front(self):
        r"""front(self) -> std::vector< unsigned long >::value_type const &"""
        return _pyBasePython.vectorUL_front(self)

    def back(self):
        r"""back(self) -> std::vector< unsigned long >::value_type const &"""
        return _pyBasePython.vectorUL_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< unsigned long >::size_type
        x: std::vector< unsigned long >::value_type const &

        """
        return _pyBasePython.vectorUL_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< unsigned long >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< unsigned long >::size_type
        x: std::vector< unsigned long >::value_type const &

        """
        return _pyBasePython.vectorUL_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< unsigned long >::iterator

        Parameters
        ----------
        pos: std::vector< unsigned long >::iterator
        x: std::vector< unsigned long >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< unsigned long >::iterator
        n: std::vector< unsigned long >::size_type
        x: std::vector< unsigned long >::value_type const &

        """
        return _pyBasePython.vectorUL_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< unsigned long >::size_type

        """
        return _pyBasePython.vectorUL_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< unsigned long >::size_type"""
        return _pyBasePython.vectorUL_capacity(self)
    __swig_destroy__ = _pyBasePython.delete_vectorUL

# Register vectorUL in _pyBasePython:
_pyBasePython.vectorUL_swigregister(vectorUL)
class vectorvectorUL(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< std::vector< unsigned long > > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.vectorvectorUL_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.vectorvectorUL___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.vectorvectorUL___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< std::vector< unsigned long > >::size_type"""
        return _pyBasePython.vectorvectorUL___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectorvectorUL

        Parameters
        ----------
        i: std::vector< std::vector< unsigned long > >::difference_type
        j: std::vector< std::vector< unsigned long > >::difference_type

        """
        return _pyBasePython.vectorvectorUL___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::vector< unsigned long > >::difference_type
        j: std::vector< std::vector< unsigned long > >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< std::vector< unsigned long > >::difference_type
        j: std::vector< std::vector< unsigned long > >::difference_type
        v: std::vector< std::vector< unsigned long,std::allocator< unsigned long > >,std::allocator< std::vector< unsigned long,std::allocator< unsigned long > > > > const &

        """
        return _pyBasePython.vectorvectorUL___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::vector< unsigned long > >::difference_type
        j: std::vector< std::vector< unsigned long > >::difference_type

        """
        return _pyBasePython.vectorvectorUL___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< std::vector< unsigned long > >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.vectorvectorUL___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectorvectorUL

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> vectorUL

        Parameters
        ----------
        i: std::vector< std::vector< unsigned long > >::difference_type

        """
        return _pyBasePython.vectorvectorUL___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< std::vector< unsigned long,std::allocator< unsigned long > >,std::allocator< std::vector< unsigned long,std::allocator< unsigned long > > > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< std::vector< unsigned long > >::difference_type
        x: std::vector< std::vector< unsigned long > >::value_type const &

        """
        return _pyBasePython.vectorvectorUL___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> vectorUL"""
        return _pyBasePython.vectorvectorUL_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< std::vector< unsigned long > >::value_type const &

        """
        return _pyBasePython.vectorvectorUL_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.vectorvectorUL_empty(self)

    def size(self):
        r"""size(self) -> std::vector< std::vector< unsigned long > >::size_type"""
        return _pyBasePython.vectorvectorUL_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< std::vector< unsigned long,std::allocator< unsigned long > > > &

        """
        return _pyBasePython.vectorvectorUL_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< std::vector< unsigned long > >::iterator"""
        return _pyBasePython.vectorvectorUL_begin(self)

    def end(self):
        r"""end(self) -> std::vector< std::vector< unsigned long > >::iterator"""
        return _pyBasePython.vectorvectorUL_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< std::vector< unsigned long > >::reverse_iterator"""
        return _pyBasePython.vectorvectorUL_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< std::vector< unsigned long > >::reverse_iterator"""
        return _pyBasePython.vectorvectorUL_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.vectorvectorUL_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< std::vector< unsigned long > >::allocator_type"""
        return _pyBasePython.vectorvectorUL_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.vectorvectorUL_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< std::vector< unsigned long > >::iterator

        Parameters
        ----------
        pos: std::vector< std::vector< unsigned long > >::iterator

        erase(self, first, last) -> std::vector< std::vector< unsigned long > >::iterator

        Parameters
        ----------
        first: std::vector< std::vector< unsigned long > >::iterator
        last: std::vector< std::vector< unsigned long > >::iterator

        """
        return _pyBasePython.vectorvectorUL_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectorvectorUL
        __init__(self, other) -> vectorvectorUL

        Parameters
        ----------
        other: std::vector< std::vector< unsigned long,std::allocator< unsigned long > > > const &

        __init__(self, size) -> vectorvectorUL

        Parameters
        ----------
        size: std::vector< std::vector< unsigned long > >::size_type

        __init__(self, size, value) -> vectorvectorUL

        Parameters
        ----------
        size: std::vector< std::vector< unsigned long > >::size_type
        value: std::vector< std::vector< unsigned long > >::value_type const &

        """
        _pyBasePython.vectorvectorUL_swiginit(self, _pyBasePython.new_vectorvectorUL(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< std::vector< unsigned long > >::value_type const &

        """
        return _pyBasePython.vectorvectorUL_push_back(self, x)

    def front(self):
        r"""front(self) -> vectorUL"""
        return _pyBasePython.vectorvectorUL_front(self)

    def back(self):
        r"""back(self) -> vectorUL"""
        return _pyBasePython.vectorvectorUL_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< std::vector< unsigned long > >::size_type
        x: std::vector< std::vector< unsigned long > >::value_type const &

        """
        return _pyBasePython.vectorvectorUL_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< std::vector< unsigned long > >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< std::vector< unsigned long > >::size_type
        x: std::vector< std::vector< unsigned long > >::value_type const &

        """
        return _pyBasePython.vectorvectorUL_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< std::vector< unsigned long > >::iterator

        Parameters
        ----------
        pos: std::vector< std::vector< unsigned long > >::iterator
        x: std::vector< std::vector< unsigned long > >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< std::vector< unsigned long > >::iterator
        n: std::vector< std::vector< unsigned long > >::size_type
        x: std::vector< std::vector< unsigned long > >::value_type const &

        """
        return _pyBasePython.vectorvectorUL_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< std::vector< unsigned long > >::size_type

        """
        return _pyBasePython.vectorvectorUL_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< std::vector< unsigned long > >::size_type"""
        return _pyBasePython.vectorvectorUL_capacity(self)
    __swig_destroy__ = _pyBasePython.delete_vectorvectorUL

# Register vectorvectorUL in _pyBasePython:
_pyBasePython.vectorvectorUL_swigregister(vectorvectorUL)
class vectorSC(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< signed char > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.vectorSC_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.vectorSC___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.vectorSC___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< signed char >::size_type"""
        return _pyBasePython.vectorSC___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectorSC

        Parameters
        ----------
        i: std::vector< signed char >::difference_type
        j: std::vector< signed char >::difference_type

        """
        return _pyBasePython.vectorSC___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< signed char >::difference_type
        j: std::vector< signed char >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< signed char >::difference_type
        j: std::vector< signed char >::difference_type
        v: std::vector< signed char,std::allocator< signed char > > const &

        """
        return _pyBasePython.vectorSC___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< signed char >::difference_type
        j: std::vector< signed char >::difference_type

        """
        return _pyBasePython.vectorSC___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< signed char >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.vectorSC___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectorSC

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> std::vector< signed char >::value_type const &

        Parameters
        ----------
        i: std::vector< signed char >::difference_type

        """
        return _pyBasePython.vectorSC___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< signed char,std::allocator< signed char > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< signed char >::difference_type
        x: std::vector< signed char >::value_type const &

        """
        return _pyBasePython.vectorSC___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> std::vector< signed char >::value_type"""
        return _pyBasePython.vectorSC_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< signed char >::value_type const &

        """
        return _pyBasePython.vectorSC_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.vectorSC_empty(self)

    def size(self):
        r"""size(self) -> std::vector< signed char >::size_type"""
        return _pyBasePython.vectorSC_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< signed char > &

        """
        return _pyBasePython.vectorSC_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< signed char >::iterator"""
        return _pyBasePython.vectorSC_begin(self)

    def end(self):
        r"""end(self) -> std::vector< signed char >::iterator"""
        return _pyBasePython.vectorSC_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< signed char >::reverse_iterator"""
        return _pyBasePython.vectorSC_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< signed char >::reverse_iterator"""
        return _pyBasePython.vectorSC_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.vectorSC_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< signed char >::allocator_type"""
        return _pyBasePython.vectorSC_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.vectorSC_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< signed char >::iterator

        Parameters
        ----------
        pos: std::vector< signed char >::iterator

        erase(self, first, last) -> std::vector< signed char >::iterator

        Parameters
        ----------
        first: std::vector< signed char >::iterator
        last: std::vector< signed char >::iterator

        """
        return _pyBasePython.vectorSC_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectorSC
        __init__(self, other) -> vectorSC

        Parameters
        ----------
        other: std::vector< signed char > const &

        __init__(self, size) -> vectorSC

        Parameters
        ----------
        size: std::vector< signed char >::size_type

        __init__(self, size, value) -> vectorSC

        Parameters
        ----------
        size: std::vector< signed char >::size_type
        value: std::vector< signed char >::value_type const &

        """
        _pyBasePython.vectorSC_swiginit(self, _pyBasePython.new_vectorSC(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< signed char >::value_type const &

        """
        return _pyBasePython.vectorSC_push_back(self, x)

    def front(self):
        r"""front(self) -> std::vector< signed char >::value_type const &"""
        return _pyBasePython.vectorSC_front(self)

    def back(self):
        r"""back(self) -> std::vector< signed char >::value_type const &"""
        return _pyBasePython.vectorSC_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< signed char >::size_type
        x: std::vector< signed char >::value_type const &

        """
        return _pyBasePython.vectorSC_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< signed char >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< signed char >::size_type
        x: std::vector< signed char >::value_type const &

        """
        return _pyBasePython.vectorSC_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< signed char >::iterator

        Parameters
        ----------
        pos: std::vector< signed char >::iterator
        x: std::vector< signed char >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< signed char >::iterator
        n: std::vector< signed char >::size_type
        x: std::vector< signed char >::value_type const &

        """
        return _pyBasePython.vectorSC_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< signed char >::size_type

        """
        return _pyBasePython.vectorSC_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< signed char >::size_type"""
        return _pyBasePython.vectorSC_capacity(self)
    __swig_destroy__ = _pyBasePython.delete_vectorSC

# Register vectorSC in _pyBasePython:
_pyBasePython.vectorSC_swigregister(vectorSC)
class vectorvectorSC(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< std::vector< signed char > > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.vectorvectorSC_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.vectorvectorSC___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.vectorvectorSC___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< std::vector< signed char > >::size_type"""
        return _pyBasePython.vectorvectorSC___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectorvectorSC

        Parameters
        ----------
        i: std::vector< std::vector< signed char > >::difference_type
        j: std::vector< std::vector< signed char > >::difference_type

        """
        return _pyBasePython.vectorvectorSC___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::vector< signed char > >::difference_type
        j: std::vector< std::vector< signed char > >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< std::vector< signed char > >::difference_type
        j: std::vector< std::vector< signed char > >::difference_type
        v: std::vector< std::vector< signed char,std::allocator< signed char > >,std::allocator< std::vector< signed char,std::allocator< signed char > > > > const &

        """
        return _pyBasePython.vectorvectorSC___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::vector< signed char > >::difference_type
        j: std::vector< std::vector< signed char > >::difference_type

        """
        return _pyBasePython.vectorvectorSC___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< std::vector< signed char > >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.vectorvectorSC___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectorvectorSC

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> vectorSC

        Parameters
        ----------
        i: std::vector< std::vector< signed char > >::difference_type

        """
        return _pyBasePython.vectorvectorSC___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< std::vector< signed char,std::allocator< signed char > >,std::allocator< std::vector< signed char,std::allocator< signed char > > > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< std::vector< signed char > >::difference_type
        x: std::vector< std::vector< signed char > >::value_type const &

        """
        return _pyBasePython.vectorvectorSC___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> vectorSC"""
        return _pyBasePython.vectorvectorSC_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< std::vector< signed char > >::value_type const &

        """
        return _pyBasePython.vectorvectorSC_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.vectorvectorSC_empty(self)

    def size(self):
        r"""size(self) -> std::vector< std::vector< signed char > >::size_type"""
        return _pyBasePython.vectorvectorSC_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< std::vector< signed char,std::allocator< signed char > > > &

        """
        return _pyBasePython.vectorvectorSC_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< std::vector< signed char > >::iterator"""
        return _pyBasePython.vectorvectorSC_begin(self)

    def end(self):
        r"""end(self) -> std::vector< std::vector< signed char > >::iterator"""
        return _pyBasePython.vectorvectorSC_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< std::vector< signed char > >::reverse_iterator"""
        return _pyBasePython.vectorvectorSC_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< std::vector< signed char > >::reverse_iterator"""
        return _pyBasePython.vectorvectorSC_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.vectorvectorSC_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< std::vector< signed char > >::allocator_type"""
        return _pyBasePython.vectorvectorSC_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.vectorvectorSC_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< std::vector< signed char > >::iterator

        Parameters
        ----------
        pos: std::vector< std::vector< signed char > >::iterator

        erase(self, first, last) -> std::vector< std::vector< signed char > >::iterator

        Parameters
        ----------
        first: std::vector< std::vector< signed char > >::iterator
        last: std::vector< std::vector< signed char > >::iterator

        """
        return _pyBasePython.vectorvectorSC_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectorvectorSC
        __init__(self, other) -> vectorvectorSC

        Parameters
        ----------
        other: std::vector< std::vector< signed char,std::allocator< signed char > > > const &

        __init__(self, size) -> vectorvectorSC

        Parameters
        ----------
        size: std::vector< std::vector< signed char > >::size_type

        __init__(self, size, value) -> vectorvectorSC

        Parameters
        ----------
        size: std::vector< std::vector< signed char > >::size_type
        value: std::vector< std::vector< signed char > >::value_type const &

        """
        _pyBasePython.vectorvectorSC_swiginit(self, _pyBasePython.new_vectorvectorSC(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< std::vector< signed char > >::value_type const &

        """
        return _pyBasePython.vectorvectorSC_push_back(self, x)

    def front(self):
        r"""front(self) -> vectorSC"""
        return _pyBasePython.vectorvectorSC_front(self)

    def back(self):
        r"""back(self) -> vectorSC"""
        return _pyBasePython.vectorvectorSC_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< std::vector< signed char > >::size_type
        x: std::vector< std::vector< signed char > >::value_type const &

        """
        return _pyBasePython.vectorvectorSC_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< std::vector< signed char > >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< std::vector< signed char > >::size_type
        x: std::vector< std::vector< signed char > >::value_type const &

        """
        return _pyBasePython.vectorvectorSC_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< std::vector< signed char > >::iterator

        Parameters
        ----------
        pos: std::vector< std::vector< signed char > >::iterator
        x: std::vector< std::vector< signed char > >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< std::vector< signed char > >::iterator
        n: std::vector< std::vector< signed char > >::size_type
        x: std::vector< std::vector< signed char > >::value_type const &

        """
        return _pyBasePython.vectorvectorSC_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< std::vector< signed char > >::size_type

        """
        return _pyBasePython.vectorvectorSC_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< std::vector< signed char > >::size_type"""
        return _pyBasePython.vectorvectorSC_capacity(self)
    __swig_destroy__ = _pyBasePython.delete_vectorvectorSC

# Register vectorvectorSC in _pyBasePython:
_pyBasePython.vectorvectorSC_swigregister(vectorvectorSC)
class vectorSS(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< short > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.vectorSS_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.vectorSS___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.vectorSS___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< short >::size_type"""
        return _pyBasePython.vectorSS___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectorSS

        Parameters
        ----------
        i: std::vector< short >::difference_type
        j: std::vector< short >::difference_type

        """
        return _pyBasePython.vectorSS___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< short >::difference_type
        j: std::vector< short >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< short >::difference_type
        j: std::vector< short >::difference_type
        v: std::vector< short,std::allocator< short > > const &

        """
        return _pyBasePython.vectorSS___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< short >::difference_type
        j: std::vector< short >::difference_type

        """
        return _pyBasePython.vectorSS___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< short >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.vectorSS___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectorSS

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> std::vector< short >::value_type const &

        Parameters
        ----------
        i: std::vector< short >::difference_type

        """
        return _pyBasePython.vectorSS___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< short,std::allocator< short > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< short >::difference_type
        x: std::vector< short >::value_type const &

        """
        return _pyBasePython.vectorSS___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> std::vector< short >::value_type"""
        return _pyBasePython.vectorSS_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< short >::value_type const &

        """
        return _pyBasePython.vectorSS_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.vectorSS_empty(self)

    def size(self):
        r"""size(self) -> std::vector< short >::size_type"""
        return _pyBasePython.vectorSS_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< short > &

        """
        return _pyBasePython.vectorSS_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< short >::iterator"""
        return _pyBasePython.vectorSS_begin(self)

    def end(self):
        r"""end(self) -> std::vector< short >::iterator"""
        return _pyBasePython.vectorSS_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< short >::reverse_iterator"""
        return _pyBasePython.vectorSS_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< short >::reverse_iterator"""
        return _pyBasePython.vectorSS_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.vectorSS_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< short >::allocator_type"""
        return _pyBasePython.vectorSS_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.vectorSS_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< short >::iterator

        Parameters
        ----------
        pos: std::vector< short >::iterator

        erase(self, first, last) -> std::vector< short >::iterator

        Parameters
        ----------
        first: std::vector< short >::iterator
        last: std::vector< short >::iterator

        """
        return _pyBasePython.vectorSS_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectorSS
        __init__(self, other) -> vectorSS

        Parameters
        ----------
        other: std::vector< short > const &

        __init__(self, size) -> vectorSS

        Parameters
        ----------
        size: std::vector< short >::size_type

        __init__(self, size, value) -> vectorSS

        Parameters
        ----------
        size: std::vector< short >::size_type
        value: std::vector< short >::value_type const &

        """
        _pyBasePython.vectorSS_swiginit(self, _pyBasePython.new_vectorSS(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< short >::value_type const &

        """
        return _pyBasePython.vectorSS_push_back(self, x)

    def front(self):
        r"""front(self) -> std::vector< short >::value_type const &"""
        return _pyBasePython.vectorSS_front(self)

    def back(self):
        r"""back(self) -> std::vector< short >::value_type const &"""
        return _pyBasePython.vectorSS_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< short >::size_type
        x: std::vector< short >::value_type const &

        """
        return _pyBasePython.vectorSS_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< short >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< short >::size_type
        x: std::vector< short >::value_type const &

        """
        return _pyBasePython.vectorSS_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< short >::iterator

        Parameters
        ----------
        pos: std::vector< short >::iterator
        x: std::vector< short >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< short >::iterator
        n: std::vector< short >::size_type
        x: std::vector< short >::value_type const &

        """
        return _pyBasePython.vectorSS_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< short >::size_type

        """
        return _pyBasePython.vectorSS_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< short >::size_type"""
        return _pyBasePython.vectorSS_capacity(self)
    __swig_destroy__ = _pyBasePython.delete_vectorSS

# Register vectorSS in _pyBasePython:
_pyBasePython.vectorSS_swigregister(vectorSS)
class vectorvectorSS(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< std::vector< short > > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.vectorvectorSS_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.vectorvectorSS___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.vectorvectorSS___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< std::vector< short > >::size_type"""
        return _pyBasePython.vectorvectorSS___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectorvectorSS

        Parameters
        ----------
        i: std::vector< std::vector< short > >::difference_type
        j: std::vector< std::vector< short > >::difference_type

        """
        return _pyBasePython.vectorvectorSS___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::vector< short > >::difference_type
        j: std::vector< std::vector< short > >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< std::vector< short > >::difference_type
        j: std::vector< std::vector< short > >::difference_type
        v: std::vector< std::vector< short,std::allocator< short > >,std::allocator< std::vector< short,std::allocator< short > > > > const &

        """
        return _pyBasePython.vectorvectorSS___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::vector< short > >::difference_type
        j: std::vector< std::vector< short > >::difference_type

        """
        return _pyBasePython.vectorvectorSS___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< std::vector< short > >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.vectorvectorSS___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectorvectorSS

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> vectorSS

        Parameters
        ----------
        i: std::vector< std::vector< short > >::difference_type

        """
        return _pyBasePython.vectorvectorSS___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< std::vector< short,std::allocator< short > >,std::allocator< std::vector< short,std::allocator< short > > > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< std::vector< short > >::difference_type
        x: std::vector< std::vector< short > >::value_type const &

        """
        return _pyBasePython.vectorvectorSS___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> vectorSS"""
        return _pyBasePython.vectorvectorSS_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< std::vector< short > >::value_type const &

        """
        return _pyBasePython.vectorvectorSS_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.vectorvectorSS_empty(self)

    def size(self):
        r"""size(self) -> std::vector< std::vector< short > >::size_type"""
        return _pyBasePython.vectorvectorSS_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< std::vector< short,std::allocator< short > > > &

        """
        return _pyBasePython.vectorvectorSS_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< std::vector< short > >::iterator"""
        return _pyBasePython.vectorvectorSS_begin(self)

    def end(self):
        r"""end(self) -> std::vector< std::vector< short > >::iterator"""
        return _pyBasePython.vectorvectorSS_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< std::vector< short > >::reverse_iterator"""
        return _pyBasePython.vectorvectorSS_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< std::vector< short > >::reverse_iterator"""
        return _pyBasePython.vectorvectorSS_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.vectorvectorSS_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< std::vector< short > >::allocator_type"""
        return _pyBasePython.vectorvectorSS_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.vectorvectorSS_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< std::vector< short > >::iterator

        Parameters
        ----------
        pos: std::vector< std::vector< short > >::iterator

        erase(self, first, last) -> std::vector< std::vector< short > >::iterator

        Parameters
        ----------
        first: std::vector< std::vector< short > >::iterator
        last: std::vector< std::vector< short > >::iterator

        """
        return _pyBasePython.vectorvectorSS_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectorvectorSS
        __init__(self, other) -> vectorvectorSS

        Parameters
        ----------
        other: std::vector< std::vector< short,std::allocator< short > > > const &

        __init__(self, size) -> vectorvectorSS

        Parameters
        ----------
        size: std::vector< std::vector< short > >::size_type

        __init__(self, size, value) -> vectorvectorSS

        Parameters
        ----------
        size: std::vector< std::vector< short > >::size_type
        value: std::vector< std::vector< short > >::value_type const &

        """
        _pyBasePython.vectorvectorSS_swiginit(self, _pyBasePython.new_vectorvectorSS(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< std::vector< short > >::value_type const &

        """
        return _pyBasePython.vectorvectorSS_push_back(self, x)

    def front(self):
        r"""front(self) -> vectorSS"""
        return _pyBasePython.vectorvectorSS_front(self)

    def back(self):
        r"""back(self) -> vectorSS"""
        return _pyBasePython.vectorvectorSS_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< std::vector< short > >::size_type
        x: std::vector< std::vector< short > >::value_type const &

        """
        return _pyBasePython.vectorvectorSS_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< std::vector< short > >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< std::vector< short > >::size_type
        x: std::vector< std::vector< short > >::value_type const &

        """
        return _pyBasePython.vectorvectorSS_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< std::vector< short > >::iterator

        Parameters
        ----------
        pos: std::vector< std::vector< short > >::iterator
        x: std::vector< std::vector< short > >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< std::vector< short > >::iterator
        n: std::vector< std::vector< short > >::size_type
        x: std::vector< std::vector< short > >::value_type const &

        """
        return _pyBasePython.vectorvectorSS_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< std::vector< short > >::size_type

        """
        return _pyBasePython.vectorvectorSS_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< std::vector< short > >::size_type"""
        return _pyBasePython.vectorvectorSS_capacity(self)
    __swig_destroy__ = _pyBasePython.delete_vectorvectorSS

# Register vectorvectorSS in _pyBasePython:
_pyBasePython.vectorvectorSS_swigregister(vectorvectorSS)
class vectorSL(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< long > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.vectorSL_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.vectorSL___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.vectorSL___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< long >::size_type"""
        return _pyBasePython.vectorSL___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectorSL

        Parameters
        ----------
        i: std::vector< long >::difference_type
        j: std::vector< long >::difference_type

        """
        return _pyBasePython.vectorSL___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< long >::difference_type
        j: std::vector< long >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< long >::difference_type
        j: std::vector< long >::difference_type
        v: std::vector< long,std::allocator< long > > const &

        """
        return _pyBasePython.vectorSL___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< long >::difference_type
        j: std::vector< long >::difference_type

        """
        return _pyBasePython.vectorSL___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< long >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.vectorSL___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectorSL

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> std::vector< long >::value_type const &

        Parameters
        ----------
        i: std::vector< long >::difference_type

        """
        return _pyBasePython.vectorSL___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< long,std::allocator< long > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< long >::difference_type
        x: std::vector< long >::value_type const &

        """
        return _pyBasePython.vectorSL___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> std::vector< long >::value_type"""
        return _pyBasePython.vectorSL_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< long >::value_type const &

        """
        return _pyBasePython.vectorSL_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.vectorSL_empty(self)

    def size(self):
        r"""size(self) -> std::vector< long >::size_type"""
        return _pyBasePython.vectorSL_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< long > &

        """
        return _pyBasePython.vectorSL_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< long >::iterator"""
        return _pyBasePython.vectorSL_begin(self)

    def end(self):
        r"""end(self) -> std::vector< long >::iterator"""
        return _pyBasePython.vectorSL_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< long >::reverse_iterator"""
        return _pyBasePython.vectorSL_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< long >::reverse_iterator"""
        return _pyBasePython.vectorSL_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.vectorSL_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< long >::allocator_type"""
        return _pyBasePython.vectorSL_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.vectorSL_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< long >::iterator

        Parameters
        ----------
        pos: std::vector< long >::iterator

        erase(self, first, last) -> std::vector< long >::iterator

        Parameters
        ----------
        first: std::vector< long >::iterator
        last: std::vector< long >::iterator

        """
        return _pyBasePython.vectorSL_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectorSL
        __init__(self, other) -> vectorSL

        Parameters
        ----------
        other: std::vector< long > const &

        __init__(self, size) -> vectorSL

        Parameters
        ----------
        size: std::vector< long >::size_type

        __init__(self, size, value) -> vectorSL

        Parameters
        ----------
        size: std::vector< long >::size_type
        value: std::vector< long >::value_type const &

        """
        _pyBasePython.vectorSL_swiginit(self, _pyBasePython.new_vectorSL(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< long >::value_type const &

        """
        return _pyBasePython.vectorSL_push_back(self, x)

    def front(self):
        r"""front(self) -> std::vector< long >::value_type const &"""
        return _pyBasePython.vectorSL_front(self)

    def back(self):
        r"""back(self) -> std::vector< long >::value_type const &"""
        return _pyBasePython.vectorSL_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< long >::size_type
        x: std::vector< long >::value_type const &

        """
        return _pyBasePython.vectorSL_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< long >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< long >::size_type
        x: std::vector< long >::value_type const &

        """
        return _pyBasePython.vectorSL_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< long >::iterator

        Parameters
        ----------
        pos: std::vector< long >::iterator
        x: std::vector< long >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< long >::iterator
        n: std::vector< long >::size_type
        x: std::vector< long >::value_type const &

        """
        return _pyBasePython.vectorSL_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< long >::size_type

        """
        return _pyBasePython.vectorSL_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< long >::size_type"""
        return _pyBasePython.vectorSL_capacity(self)
    __swig_destroy__ = _pyBasePython.delete_vectorSL

# Register vectorSL in _pyBasePython:
_pyBasePython.vectorSL_swigregister(vectorSL)
class vectorvectorSL(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< std::vector< long > > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.vectorvectorSL_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.vectorvectorSL___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.vectorvectorSL___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< std::vector< long > >::size_type"""
        return _pyBasePython.vectorvectorSL___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectorvectorSL

        Parameters
        ----------
        i: std::vector< std::vector< long > >::difference_type
        j: std::vector< std::vector< long > >::difference_type

        """
        return _pyBasePython.vectorvectorSL___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::vector< long > >::difference_type
        j: std::vector< std::vector< long > >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< std::vector< long > >::difference_type
        j: std::vector< std::vector< long > >::difference_type
        v: std::vector< std::vector< long,std::allocator< long > >,std::allocator< std::vector< long,std::allocator< long > > > > const &

        """
        return _pyBasePython.vectorvectorSL___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::vector< long > >::difference_type
        j: std::vector< std::vector< long > >::difference_type

        """
        return _pyBasePython.vectorvectorSL___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< std::vector< long > >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.vectorvectorSL___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectorvectorSL

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> vectorSL

        Parameters
        ----------
        i: std::vector< std::vector< long > >::difference_type

        """
        return _pyBasePython.vectorvectorSL___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< std::vector< long,std::allocator< long > >,std::allocator< std::vector< long,std::allocator< long > > > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< std::vector< long > >::difference_type
        x: std::vector< std::vector< long > >::value_type const &

        """
        return _pyBasePython.vectorvectorSL___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> vectorSL"""
        return _pyBasePython.vectorvectorSL_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< std::vector< long > >::value_type const &

        """
        return _pyBasePython.vectorvectorSL_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.vectorvectorSL_empty(self)

    def size(self):
        r"""size(self) -> std::vector< std::vector< long > >::size_type"""
        return _pyBasePython.vectorvectorSL_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< std::vector< long,std::allocator< long > > > &

        """
        return _pyBasePython.vectorvectorSL_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< std::vector< long > >::iterator"""
        return _pyBasePython.vectorvectorSL_begin(self)

    def end(self):
        r"""end(self) -> std::vector< std::vector< long > >::iterator"""
        return _pyBasePython.vectorvectorSL_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< std::vector< long > >::reverse_iterator"""
        return _pyBasePython.vectorvectorSL_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< std::vector< long > >::reverse_iterator"""
        return _pyBasePython.vectorvectorSL_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.vectorvectorSL_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< std::vector< long > >::allocator_type"""
        return _pyBasePython.vectorvectorSL_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.vectorvectorSL_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< std::vector< long > >::iterator

        Parameters
        ----------
        pos: std::vector< std::vector< long > >::iterator

        erase(self, first, last) -> std::vector< std::vector< long > >::iterator

        Parameters
        ----------
        first: std::vector< std::vector< long > >::iterator
        last: std::vector< std::vector< long > >::iterator

        """
        return _pyBasePython.vectorvectorSL_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectorvectorSL
        __init__(self, other) -> vectorvectorSL

        Parameters
        ----------
        other: std::vector< std::vector< long,std::allocator< long > > > const &

        __init__(self, size) -> vectorvectorSL

        Parameters
        ----------
        size: std::vector< std::vector< long > >::size_type

        __init__(self, size, value) -> vectorvectorSL

        Parameters
        ----------
        size: std::vector< std::vector< long > >::size_type
        value: std::vector< std::vector< long > >::value_type const &

        """
        _pyBasePython.vectorvectorSL_swiginit(self, _pyBasePython.new_vectorvectorSL(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< std::vector< long > >::value_type const &

        """
        return _pyBasePython.vectorvectorSL_push_back(self, x)

    def front(self):
        r"""front(self) -> vectorSL"""
        return _pyBasePython.vectorvectorSL_front(self)

    def back(self):
        r"""back(self) -> vectorSL"""
        return _pyBasePython.vectorvectorSL_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< std::vector< long > >::size_type
        x: std::vector< std::vector< long > >::value_type const &

        """
        return _pyBasePython.vectorvectorSL_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< std::vector< long > >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< std::vector< long > >::size_type
        x: std::vector< std::vector< long > >::value_type const &

        """
        return _pyBasePython.vectorvectorSL_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< std::vector< long > >::iterator

        Parameters
        ----------
        pos: std::vector< std::vector< long > >::iterator
        x: std::vector< std::vector< long > >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< std::vector< long > >::iterator
        n: std::vector< std::vector< long > >::size_type
        x: std::vector< std::vector< long > >::value_type const &

        """
        return _pyBasePython.vectorvectorSL_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< std::vector< long > >::size_type

        """
        return _pyBasePython.vectorvectorSL_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< std::vector< long > >::size_type"""
        return _pyBasePython.vectorvectorSL_capacity(self)
    __swig_destroy__ = _pyBasePython.delete_vectorvectorSL

# Register vectorvectorSL in _pyBasePython:
_pyBasePython.vectorvectorSL_swigregister(vectorvectorSL)
class vectorF(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< float > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.vectorF_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.vectorF___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.vectorF___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< float >::size_type"""
        return _pyBasePython.vectorF___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectorF

        Parameters
        ----------
        i: std::vector< float >::difference_type
        j: std::vector< float >::difference_type

        """
        return _pyBasePython.vectorF___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< float >::difference_type
        j: std::vector< float >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< float >::difference_type
        j: std::vector< float >::difference_type
        v: std::vector< float,std::allocator< float > > const &

        """
        return _pyBasePython.vectorF___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< float >::difference_type
        j: std::vector< float >::difference_type

        """
        return _pyBasePython.vectorF___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< float >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.vectorF___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectorF

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> std::vector< float >::value_type const &

        Parameters
        ----------
        i: std::vector< float >::difference_type

        """
        return _pyBasePython.vectorF___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< float,std::allocator< float > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< float >::difference_type
        x: std::vector< float >::value_type const &

        """
        return _pyBasePython.vectorF___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> std::vector< float >::value_type"""
        return _pyBasePython.vectorF_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< float >::value_type const &

        """
        return _pyBasePython.vectorF_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.vectorF_empty(self)

    def size(self):
        r"""size(self) -> std::vector< float >::size_type"""
        return _pyBasePython.vectorF_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< float > &

        """
        return _pyBasePython.vectorF_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< float >::iterator"""
        return _pyBasePython.vectorF_begin(self)

    def end(self):
        r"""end(self) -> std::vector< float >::iterator"""
        return _pyBasePython.vectorF_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< float >::reverse_iterator"""
        return _pyBasePython.vectorF_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< float >::reverse_iterator"""
        return _pyBasePython.vectorF_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.vectorF_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< float >::allocator_type"""
        return _pyBasePython.vectorF_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.vectorF_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< float >::iterator

        Parameters
        ----------
        pos: std::vector< float >::iterator

        erase(self, first, last) -> std::vector< float >::iterator

        Parameters
        ----------
        first: std::vector< float >::iterator
        last: std::vector< float >::iterator

        """
        return _pyBasePython.vectorF_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectorF
        __init__(self, other) -> vectorF

        Parameters
        ----------
        other: std::vector< float > const &

        __init__(self, size) -> vectorF

        Parameters
        ----------
        size: std::vector< float >::size_type

        __init__(self, size, value) -> vectorF

        Parameters
        ----------
        size: std::vector< float >::size_type
        value: std::vector< float >::value_type const &

        """
        _pyBasePython.vectorF_swiginit(self, _pyBasePython.new_vectorF(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< float >::value_type const &

        """
        return _pyBasePython.vectorF_push_back(self, x)

    def front(self):
        r"""front(self) -> std::vector< float >::value_type const &"""
        return _pyBasePython.vectorF_front(self)

    def back(self):
        r"""back(self) -> std::vector< float >::value_type const &"""
        return _pyBasePython.vectorF_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< float >::size_type
        x: std::vector< float >::value_type const &

        """
        return _pyBasePython.vectorF_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< float >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< float >::size_type
        x: std::vector< float >::value_type const &

        """
        return _pyBasePython.vectorF_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< float >::iterator

        Parameters
        ----------
        pos: std::vector< float >::iterator
        x: std::vector< float >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< float >::iterator
        n: std::vector< float >::size_type
        x: std::vector< float >::value_type const &

        """
        return _pyBasePython.vectorF_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< float >::size_type

        """
        return _pyBasePython.vectorF_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< float >::size_type"""
        return _pyBasePython.vectorF_capacity(self)
    __swig_destroy__ = _pyBasePython.delete_vectorF

# Register vectorF in _pyBasePython:
_pyBasePython.vectorF_swigregister(vectorF)
class vectorvectorF(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< std::vector< float > > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.vectorvectorF_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.vectorvectorF___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.vectorvectorF___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< std::vector< float > >::size_type"""
        return _pyBasePython.vectorvectorF___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectorvectorF

        Parameters
        ----------
        i: std::vector< std::vector< float > >::difference_type
        j: std::vector< std::vector< float > >::difference_type

        """
        return _pyBasePython.vectorvectorF___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::vector< float > >::difference_type
        j: std::vector< std::vector< float > >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< std::vector< float > >::difference_type
        j: std::vector< std::vector< float > >::difference_type
        v: std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const &

        """
        return _pyBasePython.vectorvectorF___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::vector< float > >::difference_type
        j: std::vector< std::vector< float > >::difference_type

        """
        return _pyBasePython.vectorvectorF___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< std::vector< float > >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.vectorvectorF___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectorvectorF

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> vectorF

        Parameters
        ----------
        i: std::vector< std::vector< float > >::difference_type

        """
        return _pyBasePython.vectorvectorF___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< std::vector< float > >::difference_type
        x: std::vector< std::vector< float > >::value_type const &

        """
        return _pyBasePython.vectorvectorF___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> vectorF"""
        return _pyBasePython.vectorvectorF_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< std::vector< float > >::value_type const &

        """
        return _pyBasePython.vectorvectorF_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.vectorvectorF_empty(self)

    def size(self):
        r"""size(self) -> std::vector< std::vector< float > >::size_type"""
        return _pyBasePython.vectorvectorF_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< std::vector< float,std::allocator< float > > > &

        """
        return _pyBasePython.vectorvectorF_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< std::vector< float > >::iterator"""
        return _pyBasePython.vectorvectorF_begin(self)

    def end(self):
        r"""end(self) -> std::vector< std::vector< float > >::iterator"""
        return _pyBasePython.vectorvectorF_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< std::vector< float > >::reverse_iterator"""
        return _pyBasePython.vectorvectorF_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< std::vector< float > >::reverse_iterator"""
        return _pyBasePython.vectorvectorF_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.vectorvectorF_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< std::vector< float > >::allocator_type"""
        return _pyBasePython.vectorvectorF_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.vectorvectorF_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< std::vector< float > >::iterator

        Parameters
        ----------
        pos: std::vector< std::vector< float > >::iterator

        erase(self, first, last) -> std::vector< std::vector< float > >::iterator

        Parameters
        ----------
        first: std::vector< std::vector< float > >::iterator
        last: std::vector< std::vector< float > >::iterator

        """
        return _pyBasePython.vectorvectorF_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectorvectorF
        __init__(self, other) -> vectorvectorF

        Parameters
        ----------
        other: std::vector< std::vector< float,std::allocator< float > > > const &

        __init__(self, size) -> vectorvectorF

        Parameters
        ----------
        size: std::vector< std::vector< float > >::size_type

        __init__(self, size, value) -> vectorvectorF

        Parameters
        ----------
        size: std::vector< std::vector< float > >::size_type
        value: std::vector< std::vector< float > >::value_type const &

        """
        _pyBasePython.vectorvectorF_swiginit(self, _pyBasePython.new_vectorvectorF(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< std::vector< float > >::value_type const &

        """
        return _pyBasePython.vectorvectorF_push_back(self, x)

    def front(self):
        r"""front(self) -> vectorF"""
        return _pyBasePython.vectorvectorF_front(self)

    def back(self):
        r"""back(self) -> vectorF"""
        return _pyBasePython.vectorvectorF_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< std::vector< float > >::size_type
        x: std::vector< std::vector< float > >::value_type const &

        """
        return _pyBasePython.vectorvectorF_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< std::vector< float > >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< std::vector< float > >::size_type
        x: std::vector< std::vector< float > >::value_type const &

        """
        return _pyBasePython.vectorvectorF_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< std::vector< float > >::iterator

        Parameters
        ----------
        pos: std::vector< std::vector< float > >::iterator
        x: std::vector< std::vector< float > >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< std::vector< float > >::iterator
        n: std::vector< std::vector< float > >::size_type
        x: std::vector< std::vector< float > >::value_type const &

        """
        return _pyBasePython.vectorvectorF_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< std::vector< float > >::size_type

        """
        return _pyBasePython.vectorvectorF_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< std::vector< float > >::size_type"""
        return _pyBasePython.vectorvectorF_capacity(self)
    __swig_destroy__ = _pyBasePython.delete_vectorvectorF

# Register vectorvectorF in _pyBasePython:
_pyBasePython.vectorvectorF_swigregister(vectorvectorF)
class vectorD(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< double > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.vectorD_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.vectorD___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.vectorD___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< double >::size_type"""
        return _pyBasePython.vectorD___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectorD

        Parameters
        ----------
        i: std::vector< double >::difference_type
        j: std::vector< double >::difference_type

        """
        return _pyBasePython.vectorD___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< double >::difference_type
        j: std::vector< double >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< double >::difference_type
        j: std::vector< double >::difference_type
        v: std::vector< double,std::allocator< double > > const &

        """
        return _pyBasePython.vectorD___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< double >::difference_type
        j: std::vector< double >::difference_type

        """
        return _pyBasePython.vectorD___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< double >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.vectorD___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectorD

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> std::vector< double >::value_type const &

        Parameters
        ----------
        i: std::vector< double >::difference_type

        """
        return _pyBasePython.vectorD___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< double,std::allocator< double > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< double >::difference_type
        x: std::vector< double >::value_type const &

        """
        return _pyBasePython.vectorD___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> std::vector< double >::value_type"""
        return _pyBasePython.vectorD_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< double >::value_type const &

        """
        return _pyBasePython.vectorD_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.vectorD_empty(self)

    def size(self):
        r"""size(self) -> std::vector< double >::size_type"""
        return _pyBasePython.vectorD_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< double > &

        """
        return _pyBasePython.vectorD_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< double >::iterator"""
        return _pyBasePython.vectorD_begin(self)

    def end(self):
        r"""end(self) -> std::vector< double >::iterator"""
        return _pyBasePython.vectorD_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< double >::reverse_iterator"""
        return _pyBasePython.vectorD_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< double >::reverse_iterator"""
        return _pyBasePython.vectorD_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.vectorD_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< double >::allocator_type"""
        return _pyBasePython.vectorD_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.vectorD_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< double >::iterator

        Parameters
        ----------
        pos: std::vector< double >::iterator

        erase(self, first, last) -> std::vector< double >::iterator

        Parameters
        ----------
        first: std::vector< double >::iterator
        last: std::vector< double >::iterator

        """
        return _pyBasePython.vectorD_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectorD
        __init__(self, other) -> vectorD

        Parameters
        ----------
        other: std::vector< double > const &

        __init__(self, size) -> vectorD

        Parameters
        ----------
        size: std::vector< double >::size_type

        __init__(self, size, value) -> vectorD

        Parameters
        ----------
        size: std::vector< double >::size_type
        value: std::vector< double >::value_type const &

        """
        _pyBasePython.vectorD_swiginit(self, _pyBasePython.new_vectorD(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< double >::value_type const &

        """
        return _pyBasePython.vectorD_push_back(self, x)

    def front(self):
        r"""front(self) -> std::vector< double >::value_type const &"""
        return _pyBasePython.vectorD_front(self)

    def back(self):
        r"""back(self) -> std::vector< double >::value_type const &"""
        return _pyBasePython.vectorD_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< double >::size_type
        x: std::vector< double >::value_type const &

        """
        return _pyBasePython.vectorD_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< double >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< double >::size_type
        x: std::vector< double >::value_type const &

        """
        return _pyBasePython.vectorD_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< double >::iterator

        Parameters
        ----------
        pos: std::vector< double >::iterator
        x: std::vector< double >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< double >::iterator
        n: std::vector< double >::size_type
        x: std::vector< double >::value_type const &

        """
        return _pyBasePython.vectorD_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< double >::size_type

        """
        return _pyBasePython.vectorD_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< double >::size_type"""
        return _pyBasePython.vectorD_capacity(self)
    __swig_destroy__ = _pyBasePython.delete_vectorD

# Register vectorD in _pyBasePython:
_pyBasePython.vectorD_swigregister(vectorD)
class vectorvectorD(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< std::vector< double > > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.vectorvectorD_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.vectorvectorD___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.vectorvectorD___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< std::vector< double > >::size_type"""
        return _pyBasePython.vectorvectorD___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectorvectorD

        Parameters
        ----------
        i: std::vector< std::vector< double > >::difference_type
        j: std::vector< std::vector< double > >::difference_type

        """
        return _pyBasePython.vectorvectorD___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::vector< double > >::difference_type
        j: std::vector< std::vector< double > >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< std::vector< double > >::difference_type
        j: std::vector< std::vector< double > >::difference_type
        v: std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &

        """
        return _pyBasePython.vectorvectorD___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::vector< double > >::difference_type
        j: std::vector< std::vector< double > >::difference_type

        """
        return _pyBasePython.vectorvectorD___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< std::vector< double > >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.vectorvectorD___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectorvectorD

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> vectorD

        Parameters
        ----------
        i: std::vector< std::vector< double > >::difference_type

        """
        return _pyBasePython.vectorvectorD___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< std::vector< double > >::difference_type
        x: std::vector< std::vector< double > >::value_type const &

        """
        return _pyBasePython.vectorvectorD___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> vectorD"""
        return _pyBasePython.vectorvectorD_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< std::vector< double > >::value_type const &

        """
        return _pyBasePython.vectorvectorD_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.vectorvectorD_empty(self)

    def size(self):
        r"""size(self) -> std::vector< std::vector< double > >::size_type"""
        return _pyBasePython.vectorvectorD_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< std::vector< double,std::allocator< double > > > &

        """
        return _pyBasePython.vectorvectorD_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< std::vector< double > >::iterator"""
        return _pyBasePython.vectorvectorD_begin(self)

    def end(self):
        r"""end(self) -> std::vector< std::vector< double > >::iterator"""
        return _pyBasePython.vectorvectorD_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< std::vector< double > >::reverse_iterator"""
        return _pyBasePython.vectorvectorD_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< std::vector< double > >::reverse_iterator"""
        return _pyBasePython.vectorvectorD_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.vectorvectorD_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< std::vector< double > >::allocator_type"""
        return _pyBasePython.vectorvectorD_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.vectorvectorD_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< std::vector< double > >::iterator

        Parameters
        ----------
        pos: std::vector< std::vector< double > >::iterator

        erase(self, first, last) -> std::vector< std::vector< double > >::iterator

        Parameters
        ----------
        first: std::vector< std::vector< double > >::iterator
        last: std::vector< std::vector< double > >::iterator

        """
        return _pyBasePython.vectorvectorD_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectorvectorD
        __init__(self, other) -> vectorvectorD

        Parameters
        ----------
        other: std::vector< std::vector< double,std::allocator< double > > > const &

        __init__(self, size) -> vectorvectorD

        Parameters
        ----------
        size: std::vector< std::vector< double > >::size_type

        __init__(self, size, value) -> vectorvectorD

        Parameters
        ----------
        size: std::vector< std::vector< double > >::size_type
        value: std::vector< std::vector< double > >::value_type const &

        """
        _pyBasePython.vectorvectorD_swiginit(self, _pyBasePython.new_vectorvectorD(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< std::vector< double > >::value_type const &

        """
        return _pyBasePython.vectorvectorD_push_back(self, x)

    def front(self):
        r"""front(self) -> vectorD"""
        return _pyBasePython.vectorvectorD_front(self)

    def back(self):
        r"""back(self) -> vectorD"""
        return _pyBasePython.vectorvectorD_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< std::vector< double > >::size_type
        x: std::vector< std::vector< double > >::value_type const &

        """
        return _pyBasePython.vectorvectorD_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< std::vector< double > >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< std::vector< double > >::size_type
        x: std::vector< std::vector< double > >::value_type const &

        """
        return _pyBasePython.vectorvectorD_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< std::vector< double > >::iterator

        Parameters
        ----------
        pos: std::vector< std::vector< double > >::iterator
        x: std::vector< std::vector< double > >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< std::vector< double > >::iterator
        n: std::vector< std::vector< double > >::size_type
        x: std::vector< std::vector< double > >::value_type const &

        """
        return _pyBasePython.vectorvectorD_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< std::vector< double > >::size_type

        """
        return _pyBasePython.vectorvectorD_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< std::vector< double > >::size_type"""
        return _pyBasePython.vectorvectorD_capacity(self)
    __swig_destroy__ = _pyBasePython.delete_vectorvectorD

# Register vectorvectorD in _pyBasePython:
_pyBasePython.vectorvectorD_swigregister(vectorvectorD)
class vectorstring(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< std::string > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.vectorstring_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.vectorstring___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.vectorstring___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< std::string >::size_type"""
        return _pyBasePython.vectorstring___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectorstring

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        j: std::vector< std::string >::difference_type

        """
        return _pyBasePython.vectorstring___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        j: std::vector< std::string >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        j: std::vector< std::string >::difference_type
        v: std::vector< std::string,std::allocator< std::string > > const &

        """
        return _pyBasePython.vectorstring___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        j: std::vector< std::string >::difference_type

        """
        return _pyBasePython.vectorstring___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.vectorstring___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectorstring

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> std::vector< std::string >::value_type const &

        Parameters
        ----------
        i: std::vector< std::string >::difference_type

        """
        return _pyBasePython.vectorstring___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< std::string,std::allocator< std::string > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        x: std::vector< std::string >::value_type const &

        """
        return _pyBasePython.vectorstring___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> std::vector< std::string >::value_type"""
        return _pyBasePython.vectorstring_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< std::string >::value_type const &

        """
        return _pyBasePython.vectorstring_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.vectorstring_empty(self)

    def size(self):
        r"""size(self) -> std::vector< std::string >::size_type"""
        return _pyBasePython.vectorstring_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< std::string > &

        """
        return _pyBasePython.vectorstring_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< std::string >::iterator"""
        return _pyBasePython.vectorstring_begin(self)

    def end(self):
        r"""end(self) -> std::vector< std::string >::iterator"""
        return _pyBasePython.vectorstring_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< std::string >::reverse_iterator"""
        return _pyBasePython.vectorstring_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< std::string >::reverse_iterator"""
        return _pyBasePython.vectorstring_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.vectorstring_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< std::string >::allocator_type"""
        return _pyBasePython.vectorstring_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.vectorstring_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< std::string >::iterator

        Parameters
        ----------
        pos: std::vector< std::string >::iterator

        erase(self, first, last) -> std::vector< std::string >::iterator

        Parameters
        ----------
        first: std::vector< std::string >::iterator
        last: std::vector< std::string >::iterator

        """
        return _pyBasePython.vectorstring_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectorstring
        __init__(self, other) -> vectorstring

        Parameters
        ----------
        other: std::vector< std::string > const &

        __init__(self, size) -> vectorstring

        Parameters
        ----------
        size: std::vector< std::string >::size_type

        __init__(self, size, value) -> vectorstring

        Parameters
        ----------
        size: std::vector< std::string >::size_type
        value: std::vector< std::string >::value_type const &

        """
        _pyBasePython.vectorstring_swiginit(self, _pyBasePython.new_vectorstring(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< std::string >::value_type const &

        """
        return _pyBasePython.vectorstring_push_back(self, x)

    def front(self):
        r"""front(self) -> std::vector< std::string >::value_type const &"""
        return _pyBasePython.vectorstring_front(self)

    def back(self):
        r"""back(self) -> std::vector< std::string >::value_type const &"""
        return _pyBasePython.vectorstring_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< std::string >::size_type
        x: std::vector< std::string >::value_type const &

        """
        return _pyBasePython.vectorstring_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< std::string >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< std::string >::size_type
        x: std::vector< std::string >::value_type const &

        """
        return _pyBasePython.vectorstring_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< std::string >::iterator

        Parameters
        ----------
        pos: std::vector< std::string >::iterator
        x: std::vector< std::string >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< std::string >::iterator
        n: std::vector< std::string >::size_type
        x: std::vector< std::string >::value_type const &

        """
        return _pyBasePython.vectorstring_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< std::string >::size_type

        """
        return _pyBasePython.vectorstring_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< std::string >::size_type"""
        return _pyBasePython.vectorstring_capacity(self)
    __swig_destroy__ = _pyBasePython.delete_vectorstring

# Register vectorstring in _pyBasePython:
_pyBasePython.vectorstring_swigregister(vectorstring)
class listB(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::list< bool > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.listB_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.listB___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.listB___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::list< bool >::size_type"""
        return _pyBasePython.listB___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> listB

        Parameters
        ----------
        i: std::list< bool >::difference_type
        j: std::list< bool >::difference_type

        """
        return _pyBasePython.listB___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::list< bool >::difference_type
        j: std::list< bool >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::list< bool >::difference_type
        j: std::list< bool >::difference_type
        v: std::list< bool,std::allocator< bool > > const &

        """
        return _pyBasePython.listB___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::list< bool >::difference_type
        j: std::list< bool >::difference_type

        """
        return _pyBasePython.listB___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::list< bool >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.listB___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> listB

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> std::list< bool >::value_type const &

        Parameters
        ----------
        i: std::list< bool >::difference_type

        """
        return _pyBasePython.listB___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::list< bool,std::allocator< bool > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::list< bool >::difference_type
        x: std::list< bool >::value_type const &

        """
        return _pyBasePython.listB___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> std::list< bool >::value_type"""
        return _pyBasePython.listB_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::list< bool >::value_type const &

        """
        return _pyBasePython.listB_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.listB_empty(self)

    def size(self):
        r"""size(self) -> std::list< bool >::size_type"""
        return _pyBasePython.listB_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::list< bool > &

        """
        return _pyBasePython.listB_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::list< bool >::iterator"""
        return _pyBasePython.listB_begin(self)

    def end(self):
        r"""end(self) -> std::list< bool >::iterator"""
        return _pyBasePython.listB_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::list< bool >::reverse_iterator"""
        return _pyBasePython.listB_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::list< bool >::reverse_iterator"""
        return _pyBasePython.listB_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.listB_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::list< bool >::allocator_type"""
        return _pyBasePython.listB_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.listB_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::list< bool >::iterator

        Parameters
        ----------
        pos: std::list< bool >::iterator

        erase(self, first, last) -> std::list< bool >::iterator

        Parameters
        ----------
        first: std::list< bool >::iterator
        last: std::list< bool >::iterator

        """
        return _pyBasePython.listB_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> listB
        __init__(self, other) -> listB

        Parameters
        ----------
        other: std::list< bool > const &

        __init__(self, size) -> listB

        Parameters
        ----------
        size: std::list< bool >::size_type

        __init__(self, size, value) -> listB

        Parameters
        ----------
        size: std::list< bool >::size_type
        value: std::list< bool >::value_type const &

        """
        _pyBasePython.listB_swiginit(self, _pyBasePython.new_listB(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::list< bool >::value_type const &

        """
        return _pyBasePython.listB_push_back(self, x)

    def front(self):
        r"""front(self) -> std::list< bool >::value_type const &"""
        return _pyBasePython.listB_front(self)

    def back(self):
        r"""back(self) -> std::list< bool >::value_type const &"""
        return _pyBasePython.listB_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::list< bool >::size_type
        x: std::list< bool >::value_type const &

        """
        return _pyBasePython.listB_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::list< bool >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::list< bool >::size_type
        x: std::list< bool >::value_type const &

        """
        return _pyBasePython.listB_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::list< bool >::iterator

        Parameters
        ----------
        pos: std::list< bool >::iterator
        x: std::list< bool >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::list< bool >::iterator
        n: std::list< bool >::size_type
        x: std::list< bool >::value_type const &

        """
        return _pyBasePython.listB_insert(self, *args)

    def pop_front(self):
        r"""pop_front(self)"""
        return _pyBasePython.listB_pop_front(self)

    def push_front(self, x):
        r"""
        push_front(self, x)

        Parameters
        ----------
        x: std::list< bool >::value_type const &

        """
        return _pyBasePython.listB_push_front(self, x)

    def reverse(self):
        r"""reverse(self)"""
        return _pyBasePython.listB_reverse(self)
    __swig_destroy__ = _pyBasePython.delete_listB

# Register listB in _pyBasePython:
_pyBasePython.listB_swigregister(listB)
class listI(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::list< int > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.listI_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.listI___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.listI___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::list< int >::size_type"""
        return _pyBasePython.listI___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> listI

        Parameters
        ----------
        i: std::list< int >::difference_type
        j: std::list< int >::difference_type

        """
        return _pyBasePython.listI___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::list< int >::difference_type
        j: std::list< int >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::list< int >::difference_type
        j: std::list< int >::difference_type
        v: std::list< int,std::allocator< int > > const &

        """
        return _pyBasePython.listI___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::list< int >::difference_type
        j: std::list< int >::difference_type

        """
        return _pyBasePython.listI___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::list< int >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.listI___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> listI

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> std::list< int >::value_type const &

        Parameters
        ----------
        i: std::list< int >::difference_type

        """
        return _pyBasePython.listI___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::list< int,std::allocator< int > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::list< int >::difference_type
        x: std::list< int >::value_type const &

        """
        return _pyBasePython.listI___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> std::list< int >::value_type"""
        return _pyBasePython.listI_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::list< int >::value_type const &

        """
        return _pyBasePython.listI_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.listI_empty(self)

    def size(self):
        r"""size(self) -> std::list< int >::size_type"""
        return _pyBasePython.listI_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::list< int > &

        """
        return _pyBasePython.listI_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::list< int >::iterator"""
        return _pyBasePython.listI_begin(self)

    def end(self):
        r"""end(self) -> std::list< int >::iterator"""
        return _pyBasePython.listI_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::list< int >::reverse_iterator"""
        return _pyBasePython.listI_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::list< int >::reverse_iterator"""
        return _pyBasePython.listI_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.listI_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::list< int >::allocator_type"""
        return _pyBasePython.listI_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.listI_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::list< int >::iterator

        Parameters
        ----------
        pos: std::list< int >::iterator

        erase(self, first, last) -> std::list< int >::iterator

        Parameters
        ----------
        first: std::list< int >::iterator
        last: std::list< int >::iterator

        """
        return _pyBasePython.listI_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> listI
        __init__(self, other) -> listI

        Parameters
        ----------
        other: std::list< int > const &

        __init__(self, size) -> listI

        Parameters
        ----------
        size: std::list< int >::size_type

        __init__(self, size, value) -> listI

        Parameters
        ----------
        size: std::list< int >::size_type
        value: std::list< int >::value_type const &

        """
        _pyBasePython.listI_swiginit(self, _pyBasePython.new_listI(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::list< int >::value_type const &

        """
        return _pyBasePython.listI_push_back(self, x)

    def front(self):
        r"""front(self) -> std::list< int >::value_type const &"""
        return _pyBasePython.listI_front(self)

    def back(self):
        r"""back(self) -> std::list< int >::value_type const &"""
        return _pyBasePython.listI_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::list< int >::size_type
        x: std::list< int >::value_type const &

        """
        return _pyBasePython.listI_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::list< int >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::list< int >::size_type
        x: std::list< int >::value_type const &

        """
        return _pyBasePython.listI_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::list< int >::iterator

        Parameters
        ----------
        pos: std::list< int >::iterator
        x: std::list< int >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::list< int >::iterator
        n: std::list< int >::size_type
        x: std::list< int >::value_type const &

        """
        return _pyBasePython.listI_insert(self, *args)

    def pop_front(self):
        r"""pop_front(self)"""
        return _pyBasePython.listI_pop_front(self)

    def push_front(self, x):
        r"""
        push_front(self, x)

        Parameters
        ----------
        x: std::list< int >::value_type const &

        """
        return _pyBasePython.listI_push_front(self, x)

    def reverse(self):
        r"""reverse(self)"""
        return _pyBasePython.listI_reverse(self)
    __swig_destroy__ = _pyBasePython.delete_listI

# Register listI in _pyBasePython:
_pyBasePython.listI_swigregister(listI)
class listUC(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::list< unsigned char > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.listUC_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.listUC___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.listUC___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::list< unsigned char >::size_type"""
        return _pyBasePython.listUC___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> listUC

        Parameters
        ----------
        i: std::list< unsigned char >::difference_type
        j: std::list< unsigned char >::difference_type

        """
        return _pyBasePython.listUC___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::list< unsigned char >::difference_type
        j: std::list< unsigned char >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::list< unsigned char >::difference_type
        j: std::list< unsigned char >::difference_type
        v: std::list< unsigned char,std::allocator< unsigned char > > const &

        """
        return _pyBasePython.listUC___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::list< unsigned char >::difference_type
        j: std::list< unsigned char >::difference_type

        """
        return _pyBasePython.listUC___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::list< unsigned char >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.listUC___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> listUC

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> std::list< unsigned char >::value_type const &

        Parameters
        ----------
        i: std::list< unsigned char >::difference_type

        """
        return _pyBasePython.listUC___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::list< unsigned char,std::allocator< unsigned char > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::list< unsigned char >::difference_type
        x: std::list< unsigned char >::value_type const &

        """
        return _pyBasePython.listUC___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> std::list< unsigned char >::value_type"""
        return _pyBasePython.listUC_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::list< unsigned char >::value_type const &

        """
        return _pyBasePython.listUC_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.listUC_empty(self)

    def size(self):
        r"""size(self) -> std::list< unsigned char >::size_type"""
        return _pyBasePython.listUC_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::list< unsigned char > &

        """
        return _pyBasePython.listUC_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::list< unsigned char >::iterator"""
        return _pyBasePython.listUC_begin(self)

    def end(self):
        r"""end(self) -> std::list< unsigned char >::iterator"""
        return _pyBasePython.listUC_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::list< unsigned char >::reverse_iterator"""
        return _pyBasePython.listUC_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::list< unsigned char >::reverse_iterator"""
        return _pyBasePython.listUC_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.listUC_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::list< unsigned char >::allocator_type"""
        return _pyBasePython.listUC_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.listUC_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::list< unsigned char >::iterator

        Parameters
        ----------
        pos: std::list< unsigned char >::iterator

        erase(self, first, last) -> std::list< unsigned char >::iterator

        Parameters
        ----------
        first: std::list< unsigned char >::iterator
        last: std::list< unsigned char >::iterator

        """
        return _pyBasePython.listUC_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> listUC
        __init__(self, other) -> listUC

        Parameters
        ----------
        other: std::list< unsigned char > const &

        __init__(self, size) -> listUC

        Parameters
        ----------
        size: std::list< unsigned char >::size_type

        __init__(self, size, value) -> listUC

        Parameters
        ----------
        size: std::list< unsigned char >::size_type
        value: std::list< unsigned char >::value_type const &

        """
        _pyBasePython.listUC_swiginit(self, _pyBasePython.new_listUC(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::list< unsigned char >::value_type const &

        """
        return _pyBasePython.listUC_push_back(self, x)

    def front(self):
        r"""front(self) -> std::list< unsigned char >::value_type const &"""
        return _pyBasePython.listUC_front(self)

    def back(self):
        r"""back(self) -> std::list< unsigned char >::value_type const &"""
        return _pyBasePython.listUC_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::list< unsigned char >::size_type
        x: std::list< unsigned char >::value_type const &

        """
        return _pyBasePython.listUC_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::list< unsigned char >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::list< unsigned char >::size_type
        x: std::list< unsigned char >::value_type const &

        """
        return _pyBasePython.listUC_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::list< unsigned char >::iterator

        Parameters
        ----------
        pos: std::list< unsigned char >::iterator
        x: std::list< unsigned char >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::list< unsigned char >::iterator
        n: std::list< unsigned char >::size_type
        x: std::list< unsigned char >::value_type const &

        """
        return _pyBasePython.listUC_insert(self, *args)

    def pop_front(self):
        r"""pop_front(self)"""
        return _pyBasePython.listUC_pop_front(self)

    def push_front(self, x):
        r"""
        push_front(self, x)

        Parameters
        ----------
        x: std::list< unsigned char >::value_type const &

        """
        return _pyBasePython.listUC_push_front(self, x)

    def reverse(self):
        r"""reverse(self)"""
        return _pyBasePython.listUC_reverse(self)
    __swig_destroy__ = _pyBasePython.delete_listUC

# Register listUC in _pyBasePython:
_pyBasePython.listUC_swigregister(listUC)
class listUS(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::list< unsigned short > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.listUS_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.listUS___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.listUS___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::list< unsigned short >::size_type"""
        return _pyBasePython.listUS___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> listUS

        Parameters
        ----------
        i: std::list< unsigned short >::difference_type
        j: std::list< unsigned short >::difference_type

        """
        return _pyBasePython.listUS___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::list< unsigned short >::difference_type
        j: std::list< unsigned short >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::list< unsigned short >::difference_type
        j: std::list< unsigned short >::difference_type
        v: std::list< unsigned short,std::allocator< unsigned short > > const &

        """
        return _pyBasePython.listUS___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::list< unsigned short >::difference_type
        j: std::list< unsigned short >::difference_type

        """
        return _pyBasePython.listUS___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::list< unsigned short >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.listUS___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> listUS

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> std::list< unsigned short >::value_type const &

        Parameters
        ----------
        i: std::list< unsigned short >::difference_type

        """
        return _pyBasePython.listUS___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::list< unsigned short,std::allocator< unsigned short > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::list< unsigned short >::difference_type
        x: std::list< unsigned short >::value_type const &

        """
        return _pyBasePython.listUS___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> std::list< unsigned short >::value_type"""
        return _pyBasePython.listUS_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::list< unsigned short >::value_type const &

        """
        return _pyBasePython.listUS_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.listUS_empty(self)

    def size(self):
        r"""size(self) -> std::list< unsigned short >::size_type"""
        return _pyBasePython.listUS_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::list< unsigned short > &

        """
        return _pyBasePython.listUS_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::list< unsigned short >::iterator"""
        return _pyBasePython.listUS_begin(self)

    def end(self):
        r"""end(self) -> std::list< unsigned short >::iterator"""
        return _pyBasePython.listUS_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::list< unsigned short >::reverse_iterator"""
        return _pyBasePython.listUS_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::list< unsigned short >::reverse_iterator"""
        return _pyBasePython.listUS_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.listUS_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::list< unsigned short >::allocator_type"""
        return _pyBasePython.listUS_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.listUS_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::list< unsigned short >::iterator

        Parameters
        ----------
        pos: std::list< unsigned short >::iterator

        erase(self, first, last) -> std::list< unsigned short >::iterator

        Parameters
        ----------
        first: std::list< unsigned short >::iterator
        last: std::list< unsigned short >::iterator

        """
        return _pyBasePython.listUS_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> listUS
        __init__(self, other) -> listUS

        Parameters
        ----------
        other: std::list< unsigned short > const &

        __init__(self, size) -> listUS

        Parameters
        ----------
        size: std::list< unsigned short >::size_type

        __init__(self, size, value) -> listUS

        Parameters
        ----------
        size: std::list< unsigned short >::size_type
        value: std::list< unsigned short >::value_type const &

        """
        _pyBasePython.listUS_swiginit(self, _pyBasePython.new_listUS(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::list< unsigned short >::value_type const &

        """
        return _pyBasePython.listUS_push_back(self, x)

    def front(self):
        r"""front(self) -> std::list< unsigned short >::value_type const &"""
        return _pyBasePython.listUS_front(self)

    def back(self):
        r"""back(self) -> std::list< unsigned short >::value_type const &"""
        return _pyBasePython.listUS_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::list< unsigned short >::size_type
        x: std::list< unsigned short >::value_type const &

        """
        return _pyBasePython.listUS_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::list< unsigned short >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::list< unsigned short >::size_type
        x: std::list< unsigned short >::value_type const &

        """
        return _pyBasePython.listUS_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::list< unsigned short >::iterator

        Parameters
        ----------
        pos: std::list< unsigned short >::iterator
        x: std::list< unsigned short >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::list< unsigned short >::iterator
        n: std::list< unsigned short >::size_type
        x: std::list< unsigned short >::value_type const &

        """
        return _pyBasePython.listUS_insert(self, *args)

    def pop_front(self):
        r"""pop_front(self)"""
        return _pyBasePython.listUS_pop_front(self)

    def push_front(self, x):
        r"""
        push_front(self, x)

        Parameters
        ----------
        x: std::list< unsigned short >::value_type const &

        """
        return _pyBasePython.listUS_push_front(self, x)

    def reverse(self):
        r"""reverse(self)"""
        return _pyBasePython.listUS_reverse(self)
    __swig_destroy__ = _pyBasePython.delete_listUS

# Register listUS in _pyBasePython:
_pyBasePython.listUS_swigregister(listUS)
class listUI(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::list< unsigned int > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.listUI_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.listUI___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.listUI___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::list< unsigned int >::size_type"""
        return _pyBasePython.listUI___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> listUI

        Parameters
        ----------
        i: std::list< unsigned int >::difference_type
        j: std::list< unsigned int >::difference_type

        """
        return _pyBasePython.listUI___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::list< unsigned int >::difference_type
        j: std::list< unsigned int >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::list< unsigned int >::difference_type
        j: std::list< unsigned int >::difference_type
        v: std::list< unsigned int,std::allocator< unsigned int > > const &

        """
        return _pyBasePython.listUI___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::list< unsigned int >::difference_type
        j: std::list< unsigned int >::difference_type

        """
        return _pyBasePython.listUI___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::list< unsigned int >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.listUI___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> listUI

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> std::list< unsigned int >::value_type const &

        Parameters
        ----------
        i: std::list< unsigned int >::difference_type

        """
        return _pyBasePython.listUI___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::list< unsigned int,std::allocator< unsigned int > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::list< unsigned int >::difference_type
        x: std::list< unsigned int >::value_type const &

        """
        return _pyBasePython.listUI___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> std::list< unsigned int >::value_type"""
        return _pyBasePython.listUI_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::list< unsigned int >::value_type const &

        """
        return _pyBasePython.listUI_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.listUI_empty(self)

    def size(self):
        r"""size(self) -> std::list< unsigned int >::size_type"""
        return _pyBasePython.listUI_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::list< unsigned int > &

        """
        return _pyBasePython.listUI_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::list< unsigned int >::iterator"""
        return _pyBasePython.listUI_begin(self)

    def end(self):
        r"""end(self) -> std::list< unsigned int >::iterator"""
        return _pyBasePython.listUI_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::list< unsigned int >::reverse_iterator"""
        return _pyBasePython.listUI_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::list< unsigned int >::reverse_iterator"""
        return _pyBasePython.listUI_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.listUI_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::list< unsigned int >::allocator_type"""
        return _pyBasePython.listUI_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.listUI_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::list< unsigned int >::iterator

        Parameters
        ----------
        pos: std::list< unsigned int >::iterator

        erase(self, first, last) -> std::list< unsigned int >::iterator

        Parameters
        ----------
        first: std::list< unsigned int >::iterator
        last: std::list< unsigned int >::iterator

        """
        return _pyBasePython.listUI_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> listUI
        __init__(self, other) -> listUI

        Parameters
        ----------
        other: std::list< unsigned int > const &

        __init__(self, size) -> listUI

        Parameters
        ----------
        size: std::list< unsigned int >::size_type

        __init__(self, size, value) -> listUI

        Parameters
        ----------
        size: std::list< unsigned int >::size_type
        value: std::list< unsigned int >::value_type const &

        """
        _pyBasePython.listUI_swiginit(self, _pyBasePython.new_listUI(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::list< unsigned int >::value_type const &

        """
        return _pyBasePython.listUI_push_back(self, x)

    def front(self):
        r"""front(self) -> std::list< unsigned int >::value_type const &"""
        return _pyBasePython.listUI_front(self)

    def back(self):
        r"""back(self) -> std::list< unsigned int >::value_type const &"""
        return _pyBasePython.listUI_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::list< unsigned int >::size_type
        x: std::list< unsigned int >::value_type const &

        """
        return _pyBasePython.listUI_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::list< unsigned int >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::list< unsigned int >::size_type
        x: std::list< unsigned int >::value_type const &

        """
        return _pyBasePython.listUI_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::list< unsigned int >::iterator

        Parameters
        ----------
        pos: std::list< unsigned int >::iterator
        x: std::list< unsigned int >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::list< unsigned int >::iterator
        n: std::list< unsigned int >::size_type
        x: std::list< unsigned int >::value_type const &

        """
        return _pyBasePython.listUI_insert(self, *args)

    def pop_front(self):
        r"""pop_front(self)"""
        return _pyBasePython.listUI_pop_front(self)

    def push_front(self, x):
        r"""
        push_front(self, x)

        Parameters
        ----------
        x: std::list< unsigned int >::value_type const &

        """
        return _pyBasePython.listUI_push_front(self, x)

    def reverse(self):
        r"""reverse(self)"""
        return _pyBasePython.listUI_reverse(self)
    __swig_destroy__ = _pyBasePython.delete_listUI

# Register listUI in _pyBasePython:
_pyBasePython.listUI_swigregister(listUI)
class listUL(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::list< unsigned long > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.listUL_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.listUL___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.listUL___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::list< unsigned long >::size_type"""
        return _pyBasePython.listUL___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> listUL

        Parameters
        ----------
        i: std::list< unsigned long >::difference_type
        j: std::list< unsigned long >::difference_type

        """
        return _pyBasePython.listUL___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::list< unsigned long >::difference_type
        j: std::list< unsigned long >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::list< unsigned long >::difference_type
        j: std::list< unsigned long >::difference_type
        v: std::list< unsigned long,std::allocator< unsigned long > > const &

        """
        return _pyBasePython.listUL___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::list< unsigned long >::difference_type
        j: std::list< unsigned long >::difference_type

        """
        return _pyBasePython.listUL___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::list< unsigned long >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.listUL___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> listUL

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> std::list< unsigned long >::value_type const &

        Parameters
        ----------
        i: std::list< unsigned long >::difference_type

        """
        return _pyBasePython.listUL___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::list< unsigned long,std::allocator< unsigned long > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::list< unsigned long >::difference_type
        x: std::list< unsigned long >::value_type const &

        """
        return _pyBasePython.listUL___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> std::list< unsigned long >::value_type"""
        return _pyBasePython.listUL_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::list< unsigned long >::value_type const &

        """
        return _pyBasePython.listUL_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.listUL_empty(self)

    def size(self):
        r"""size(self) -> std::list< unsigned long >::size_type"""
        return _pyBasePython.listUL_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::list< unsigned long > &

        """
        return _pyBasePython.listUL_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::list< unsigned long >::iterator"""
        return _pyBasePython.listUL_begin(self)

    def end(self):
        r"""end(self) -> std::list< unsigned long >::iterator"""
        return _pyBasePython.listUL_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::list< unsigned long >::reverse_iterator"""
        return _pyBasePython.listUL_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::list< unsigned long >::reverse_iterator"""
        return _pyBasePython.listUL_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.listUL_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::list< unsigned long >::allocator_type"""
        return _pyBasePython.listUL_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.listUL_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::list< unsigned long >::iterator

        Parameters
        ----------
        pos: std::list< unsigned long >::iterator

        erase(self, first, last) -> std::list< unsigned long >::iterator

        Parameters
        ----------
        first: std::list< unsigned long >::iterator
        last: std::list< unsigned long >::iterator

        """
        return _pyBasePython.listUL_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> listUL
        __init__(self, other) -> listUL

        Parameters
        ----------
        other: std::list< unsigned long > const &

        __init__(self, size) -> listUL

        Parameters
        ----------
        size: std::list< unsigned long >::size_type

        __init__(self, size, value) -> listUL

        Parameters
        ----------
        size: std::list< unsigned long >::size_type
        value: std::list< unsigned long >::value_type const &

        """
        _pyBasePython.listUL_swiginit(self, _pyBasePython.new_listUL(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::list< unsigned long >::value_type const &

        """
        return _pyBasePython.listUL_push_back(self, x)

    def front(self):
        r"""front(self) -> std::list< unsigned long >::value_type const &"""
        return _pyBasePython.listUL_front(self)

    def back(self):
        r"""back(self) -> std::list< unsigned long >::value_type const &"""
        return _pyBasePython.listUL_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::list< unsigned long >::size_type
        x: std::list< unsigned long >::value_type const &

        """
        return _pyBasePython.listUL_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::list< unsigned long >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::list< unsigned long >::size_type
        x: std::list< unsigned long >::value_type const &

        """
        return _pyBasePython.listUL_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::list< unsigned long >::iterator

        Parameters
        ----------
        pos: std::list< unsigned long >::iterator
        x: std::list< unsigned long >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::list< unsigned long >::iterator
        n: std::list< unsigned long >::size_type
        x: std::list< unsigned long >::value_type const &

        """
        return _pyBasePython.listUL_insert(self, *args)

    def pop_front(self):
        r"""pop_front(self)"""
        return _pyBasePython.listUL_pop_front(self)

    def push_front(self, x):
        r"""
        push_front(self, x)

        Parameters
        ----------
        x: std::list< unsigned long >::value_type const &

        """
        return _pyBasePython.listUL_push_front(self, x)

    def reverse(self):
        r"""reverse(self)"""
        return _pyBasePython.listUL_reverse(self)
    __swig_destroy__ = _pyBasePython.delete_listUL

# Register listUL in _pyBasePython:
_pyBasePython.listUL_swigregister(listUL)
class listSC(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::list< signed char > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.listSC_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.listSC___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.listSC___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::list< signed char >::size_type"""
        return _pyBasePython.listSC___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> listSC

        Parameters
        ----------
        i: std::list< signed char >::difference_type
        j: std::list< signed char >::difference_type

        """
        return _pyBasePython.listSC___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::list< signed char >::difference_type
        j: std::list< signed char >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::list< signed char >::difference_type
        j: std::list< signed char >::difference_type
        v: std::list< signed char,std::allocator< signed char > > const &

        """
        return _pyBasePython.listSC___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::list< signed char >::difference_type
        j: std::list< signed char >::difference_type

        """
        return _pyBasePython.listSC___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::list< signed char >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.listSC___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> listSC

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> std::list< signed char >::value_type const &

        Parameters
        ----------
        i: std::list< signed char >::difference_type

        """
        return _pyBasePython.listSC___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::list< signed char,std::allocator< signed char > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::list< signed char >::difference_type
        x: std::list< signed char >::value_type const &

        """
        return _pyBasePython.listSC___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> std::list< signed char >::value_type"""
        return _pyBasePython.listSC_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::list< signed char >::value_type const &

        """
        return _pyBasePython.listSC_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.listSC_empty(self)

    def size(self):
        r"""size(self) -> std::list< signed char >::size_type"""
        return _pyBasePython.listSC_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::list< signed char > &

        """
        return _pyBasePython.listSC_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::list< signed char >::iterator"""
        return _pyBasePython.listSC_begin(self)

    def end(self):
        r"""end(self) -> std::list< signed char >::iterator"""
        return _pyBasePython.listSC_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::list< signed char >::reverse_iterator"""
        return _pyBasePython.listSC_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::list< signed char >::reverse_iterator"""
        return _pyBasePython.listSC_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.listSC_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::list< signed char >::allocator_type"""
        return _pyBasePython.listSC_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.listSC_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::list< signed char >::iterator

        Parameters
        ----------
        pos: std::list< signed char >::iterator

        erase(self, first, last) -> std::list< signed char >::iterator

        Parameters
        ----------
        first: std::list< signed char >::iterator
        last: std::list< signed char >::iterator

        """
        return _pyBasePython.listSC_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> listSC
        __init__(self, other) -> listSC

        Parameters
        ----------
        other: std::list< signed char > const &

        __init__(self, size) -> listSC

        Parameters
        ----------
        size: std::list< signed char >::size_type

        __init__(self, size, value) -> listSC

        Parameters
        ----------
        size: std::list< signed char >::size_type
        value: std::list< signed char >::value_type const &

        """
        _pyBasePython.listSC_swiginit(self, _pyBasePython.new_listSC(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::list< signed char >::value_type const &

        """
        return _pyBasePython.listSC_push_back(self, x)

    def front(self):
        r"""front(self) -> std::list< signed char >::value_type const &"""
        return _pyBasePython.listSC_front(self)

    def back(self):
        r"""back(self) -> std::list< signed char >::value_type const &"""
        return _pyBasePython.listSC_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::list< signed char >::size_type
        x: std::list< signed char >::value_type const &

        """
        return _pyBasePython.listSC_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::list< signed char >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::list< signed char >::size_type
        x: std::list< signed char >::value_type const &

        """
        return _pyBasePython.listSC_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::list< signed char >::iterator

        Parameters
        ----------
        pos: std::list< signed char >::iterator
        x: std::list< signed char >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::list< signed char >::iterator
        n: std::list< signed char >::size_type
        x: std::list< signed char >::value_type const &

        """
        return _pyBasePython.listSC_insert(self, *args)

    def pop_front(self):
        r"""pop_front(self)"""
        return _pyBasePython.listSC_pop_front(self)

    def push_front(self, x):
        r"""
        push_front(self, x)

        Parameters
        ----------
        x: std::list< signed char >::value_type const &

        """
        return _pyBasePython.listSC_push_front(self, x)

    def reverse(self):
        r"""reverse(self)"""
        return _pyBasePython.listSC_reverse(self)
    __swig_destroy__ = _pyBasePython.delete_listSC

# Register listSC in _pyBasePython:
_pyBasePython.listSC_swigregister(listSC)
class listSS(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::list< short > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.listSS_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.listSS___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.listSS___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::list< short >::size_type"""
        return _pyBasePython.listSS___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> listSS

        Parameters
        ----------
        i: std::list< short >::difference_type
        j: std::list< short >::difference_type

        """
        return _pyBasePython.listSS___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::list< short >::difference_type
        j: std::list< short >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::list< short >::difference_type
        j: std::list< short >::difference_type
        v: std::list< short,std::allocator< short > > const &

        """
        return _pyBasePython.listSS___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::list< short >::difference_type
        j: std::list< short >::difference_type

        """
        return _pyBasePython.listSS___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::list< short >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.listSS___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> listSS

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> std::list< short >::value_type const &

        Parameters
        ----------
        i: std::list< short >::difference_type

        """
        return _pyBasePython.listSS___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::list< short,std::allocator< short > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::list< short >::difference_type
        x: std::list< short >::value_type const &

        """
        return _pyBasePython.listSS___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> std::list< short >::value_type"""
        return _pyBasePython.listSS_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::list< short >::value_type const &

        """
        return _pyBasePython.listSS_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.listSS_empty(self)

    def size(self):
        r"""size(self) -> std::list< short >::size_type"""
        return _pyBasePython.listSS_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::list< short > &

        """
        return _pyBasePython.listSS_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::list< short >::iterator"""
        return _pyBasePython.listSS_begin(self)

    def end(self):
        r"""end(self) -> std::list< short >::iterator"""
        return _pyBasePython.listSS_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::list< short >::reverse_iterator"""
        return _pyBasePython.listSS_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::list< short >::reverse_iterator"""
        return _pyBasePython.listSS_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.listSS_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::list< short >::allocator_type"""
        return _pyBasePython.listSS_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.listSS_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::list< short >::iterator

        Parameters
        ----------
        pos: std::list< short >::iterator

        erase(self, first, last) -> std::list< short >::iterator

        Parameters
        ----------
        first: std::list< short >::iterator
        last: std::list< short >::iterator

        """
        return _pyBasePython.listSS_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> listSS
        __init__(self, other) -> listSS

        Parameters
        ----------
        other: std::list< short > const &

        __init__(self, size) -> listSS

        Parameters
        ----------
        size: std::list< short >::size_type

        __init__(self, size, value) -> listSS

        Parameters
        ----------
        size: std::list< short >::size_type
        value: std::list< short >::value_type const &

        """
        _pyBasePython.listSS_swiginit(self, _pyBasePython.new_listSS(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::list< short >::value_type const &

        """
        return _pyBasePython.listSS_push_back(self, x)

    def front(self):
        r"""front(self) -> std::list< short >::value_type const &"""
        return _pyBasePython.listSS_front(self)

    def back(self):
        r"""back(self) -> std::list< short >::value_type const &"""
        return _pyBasePython.listSS_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::list< short >::size_type
        x: std::list< short >::value_type const &

        """
        return _pyBasePython.listSS_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::list< short >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::list< short >::size_type
        x: std::list< short >::value_type const &

        """
        return _pyBasePython.listSS_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::list< short >::iterator

        Parameters
        ----------
        pos: std::list< short >::iterator
        x: std::list< short >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::list< short >::iterator
        n: std::list< short >::size_type
        x: std::list< short >::value_type const &

        """
        return _pyBasePython.listSS_insert(self, *args)

    def pop_front(self):
        r"""pop_front(self)"""
        return _pyBasePython.listSS_pop_front(self)

    def push_front(self, x):
        r"""
        push_front(self, x)

        Parameters
        ----------
        x: std::list< short >::value_type const &

        """
        return _pyBasePython.listSS_push_front(self, x)

    def reverse(self):
        r"""reverse(self)"""
        return _pyBasePython.listSS_reverse(self)
    __swig_destroy__ = _pyBasePython.delete_listSS

# Register listSS in _pyBasePython:
_pyBasePython.listSS_swigregister(listSS)
class listSL(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::list< long > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.listSL_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.listSL___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.listSL___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::list< long >::size_type"""
        return _pyBasePython.listSL___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> listSL

        Parameters
        ----------
        i: std::list< long >::difference_type
        j: std::list< long >::difference_type

        """
        return _pyBasePython.listSL___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::list< long >::difference_type
        j: std::list< long >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::list< long >::difference_type
        j: std::list< long >::difference_type
        v: std::list< long,std::allocator< long > > const &

        """
        return _pyBasePython.listSL___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::list< long >::difference_type
        j: std::list< long >::difference_type

        """
        return _pyBasePython.listSL___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::list< long >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.listSL___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> listSL

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> std::list< long >::value_type const &

        Parameters
        ----------
        i: std::list< long >::difference_type

        """
        return _pyBasePython.listSL___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::list< long,std::allocator< long > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::list< long >::difference_type
        x: std::list< long >::value_type const &

        """
        return _pyBasePython.listSL___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> std::list< long >::value_type"""
        return _pyBasePython.listSL_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::list< long >::value_type const &

        """
        return _pyBasePython.listSL_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.listSL_empty(self)

    def size(self):
        r"""size(self) -> std::list< long >::size_type"""
        return _pyBasePython.listSL_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::list< long > &

        """
        return _pyBasePython.listSL_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::list< long >::iterator"""
        return _pyBasePython.listSL_begin(self)

    def end(self):
        r"""end(self) -> std::list< long >::iterator"""
        return _pyBasePython.listSL_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::list< long >::reverse_iterator"""
        return _pyBasePython.listSL_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::list< long >::reverse_iterator"""
        return _pyBasePython.listSL_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.listSL_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::list< long >::allocator_type"""
        return _pyBasePython.listSL_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.listSL_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::list< long >::iterator

        Parameters
        ----------
        pos: std::list< long >::iterator

        erase(self, first, last) -> std::list< long >::iterator

        Parameters
        ----------
        first: std::list< long >::iterator
        last: std::list< long >::iterator

        """
        return _pyBasePython.listSL_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> listSL
        __init__(self, other) -> listSL

        Parameters
        ----------
        other: std::list< long > const &

        __init__(self, size) -> listSL

        Parameters
        ----------
        size: std::list< long >::size_type

        __init__(self, size, value) -> listSL

        Parameters
        ----------
        size: std::list< long >::size_type
        value: std::list< long >::value_type const &

        """
        _pyBasePython.listSL_swiginit(self, _pyBasePython.new_listSL(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::list< long >::value_type const &

        """
        return _pyBasePython.listSL_push_back(self, x)

    def front(self):
        r"""front(self) -> std::list< long >::value_type const &"""
        return _pyBasePython.listSL_front(self)

    def back(self):
        r"""back(self) -> std::list< long >::value_type const &"""
        return _pyBasePython.listSL_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::list< long >::size_type
        x: std::list< long >::value_type const &

        """
        return _pyBasePython.listSL_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::list< long >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::list< long >::size_type
        x: std::list< long >::value_type const &

        """
        return _pyBasePython.listSL_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::list< long >::iterator

        Parameters
        ----------
        pos: std::list< long >::iterator
        x: std::list< long >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::list< long >::iterator
        n: std::list< long >::size_type
        x: std::list< long >::value_type const &

        """
        return _pyBasePython.listSL_insert(self, *args)

    def pop_front(self):
        r"""pop_front(self)"""
        return _pyBasePython.listSL_pop_front(self)

    def push_front(self, x):
        r"""
        push_front(self, x)

        Parameters
        ----------
        x: std::list< long >::value_type const &

        """
        return _pyBasePython.listSL_push_front(self, x)

    def reverse(self):
        r"""reverse(self)"""
        return _pyBasePython.listSL_reverse(self)
    __swig_destroy__ = _pyBasePython.delete_listSL

# Register listSL in _pyBasePython:
_pyBasePython.listSL_swigregister(listSL)
class listF(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::list< float > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.listF_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.listF___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.listF___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::list< float >::size_type"""
        return _pyBasePython.listF___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> listF

        Parameters
        ----------
        i: std::list< float >::difference_type
        j: std::list< float >::difference_type

        """
        return _pyBasePython.listF___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::list< float >::difference_type
        j: std::list< float >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::list< float >::difference_type
        j: std::list< float >::difference_type
        v: std::list< float,std::allocator< float > > const &

        """
        return _pyBasePython.listF___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::list< float >::difference_type
        j: std::list< float >::difference_type

        """
        return _pyBasePython.listF___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::list< float >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.listF___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> listF

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> std::list< float >::value_type const &

        Parameters
        ----------
        i: std::list< float >::difference_type

        """
        return _pyBasePython.listF___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::list< float,std::allocator< float > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::list< float >::difference_type
        x: std::list< float >::value_type const &

        """
        return _pyBasePython.listF___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> std::list< float >::value_type"""
        return _pyBasePython.listF_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::list< float >::value_type const &

        """
        return _pyBasePython.listF_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.listF_empty(self)

    def size(self):
        r"""size(self) -> std::list< float >::size_type"""
        return _pyBasePython.listF_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::list< float > &

        """
        return _pyBasePython.listF_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::list< float >::iterator"""
        return _pyBasePython.listF_begin(self)

    def end(self):
        r"""end(self) -> std::list< float >::iterator"""
        return _pyBasePython.listF_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::list< float >::reverse_iterator"""
        return _pyBasePython.listF_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::list< float >::reverse_iterator"""
        return _pyBasePython.listF_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.listF_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::list< float >::allocator_type"""
        return _pyBasePython.listF_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.listF_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::list< float >::iterator

        Parameters
        ----------
        pos: std::list< float >::iterator

        erase(self, first, last) -> std::list< float >::iterator

        Parameters
        ----------
        first: std::list< float >::iterator
        last: std::list< float >::iterator

        """
        return _pyBasePython.listF_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> listF
        __init__(self, other) -> listF

        Parameters
        ----------
        other: std::list< float > const &

        __init__(self, size) -> listF

        Parameters
        ----------
        size: std::list< float >::size_type

        __init__(self, size, value) -> listF

        Parameters
        ----------
        size: std::list< float >::size_type
        value: std::list< float >::value_type const &

        """
        _pyBasePython.listF_swiginit(self, _pyBasePython.new_listF(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::list< float >::value_type const &

        """
        return _pyBasePython.listF_push_back(self, x)

    def front(self):
        r"""front(self) -> std::list< float >::value_type const &"""
        return _pyBasePython.listF_front(self)

    def back(self):
        r"""back(self) -> std::list< float >::value_type const &"""
        return _pyBasePython.listF_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::list< float >::size_type
        x: std::list< float >::value_type const &

        """
        return _pyBasePython.listF_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::list< float >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::list< float >::size_type
        x: std::list< float >::value_type const &

        """
        return _pyBasePython.listF_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::list< float >::iterator

        Parameters
        ----------
        pos: std::list< float >::iterator
        x: std::list< float >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::list< float >::iterator
        n: std::list< float >::size_type
        x: std::list< float >::value_type const &

        """
        return _pyBasePython.listF_insert(self, *args)

    def pop_front(self):
        r"""pop_front(self)"""
        return _pyBasePython.listF_pop_front(self)

    def push_front(self, x):
        r"""
        push_front(self, x)

        Parameters
        ----------
        x: std::list< float >::value_type const &

        """
        return _pyBasePython.listF_push_front(self, x)

    def reverse(self):
        r"""reverse(self)"""
        return _pyBasePython.listF_reverse(self)
    __swig_destroy__ = _pyBasePython.delete_listF

# Register listF in _pyBasePython:
_pyBasePython.listF_swigregister(listF)
class listD(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::list< double > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.listD_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.listD___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.listD___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::list< double >::size_type"""
        return _pyBasePython.listD___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> listD

        Parameters
        ----------
        i: std::list< double >::difference_type
        j: std::list< double >::difference_type

        """
        return _pyBasePython.listD___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::list< double >::difference_type
        j: std::list< double >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::list< double >::difference_type
        j: std::list< double >::difference_type
        v: std::list< double,std::allocator< double > > const &

        """
        return _pyBasePython.listD___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::list< double >::difference_type
        j: std::list< double >::difference_type

        """
        return _pyBasePython.listD___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::list< double >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.listD___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> listD

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> std::list< double >::value_type const &

        Parameters
        ----------
        i: std::list< double >::difference_type

        """
        return _pyBasePython.listD___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::list< double,std::allocator< double > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::list< double >::difference_type
        x: std::list< double >::value_type const &

        """
        return _pyBasePython.listD___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> std::list< double >::value_type"""
        return _pyBasePython.listD_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::list< double >::value_type const &

        """
        return _pyBasePython.listD_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.listD_empty(self)

    def size(self):
        r"""size(self) -> std::list< double >::size_type"""
        return _pyBasePython.listD_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::list< double > &

        """
        return _pyBasePython.listD_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::list< double >::iterator"""
        return _pyBasePython.listD_begin(self)

    def end(self):
        r"""end(self) -> std::list< double >::iterator"""
        return _pyBasePython.listD_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::list< double >::reverse_iterator"""
        return _pyBasePython.listD_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::list< double >::reverse_iterator"""
        return _pyBasePython.listD_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.listD_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::list< double >::allocator_type"""
        return _pyBasePython.listD_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.listD_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::list< double >::iterator

        Parameters
        ----------
        pos: std::list< double >::iterator

        erase(self, first, last) -> std::list< double >::iterator

        Parameters
        ----------
        first: std::list< double >::iterator
        last: std::list< double >::iterator

        """
        return _pyBasePython.listD_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> listD
        __init__(self, other) -> listD

        Parameters
        ----------
        other: std::list< double > const &

        __init__(self, size) -> listD

        Parameters
        ----------
        size: std::list< double >::size_type

        __init__(self, size, value) -> listD

        Parameters
        ----------
        size: std::list< double >::size_type
        value: std::list< double >::value_type const &

        """
        _pyBasePython.listD_swiginit(self, _pyBasePython.new_listD(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::list< double >::value_type const &

        """
        return _pyBasePython.listD_push_back(self, x)

    def front(self):
        r"""front(self) -> std::list< double >::value_type const &"""
        return _pyBasePython.listD_front(self)

    def back(self):
        r"""back(self) -> std::list< double >::value_type const &"""
        return _pyBasePython.listD_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::list< double >::size_type
        x: std::list< double >::value_type const &

        """
        return _pyBasePython.listD_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::list< double >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::list< double >::size_type
        x: std::list< double >::value_type const &

        """
        return _pyBasePython.listD_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::list< double >::iterator

        Parameters
        ----------
        pos: std::list< double >::iterator
        x: std::list< double >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::list< double >::iterator
        n: std::list< double >::size_type
        x: std::list< double >::value_type const &

        """
        return _pyBasePython.listD_insert(self, *args)

    def pop_front(self):
        r"""pop_front(self)"""
        return _pyBasePython.listD_pop_front(self)

    def push_front(self, x):
        r"""
        push_front(self, x)

        Parameters
        ----------
        x: std::list< double >::value_type const &

        """
        return _pyBasePython.listD_push_front(self, x)

    def reverse(self):
        r"""reverse(self)"""
        return _pyBasePython.listD_reverse(self)
    __swig_destroy__ = _pyBasePython.delete_listD

# Register listD in _pyBasePython:
_pyBasePython.listD_swigregister(listD)
class liststring(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::list< std::string > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.liststring_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.liststring___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.liststring___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::list< std::string >::size_type"""
        return _pyBasePython.liststring___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> liststring

        Parameters
        ----------
        i: std::list< std::string >::difference_type
        j: std::list< std::string >::difference_type

        """
        return _pyBasePython.liststring___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::list< std::string >::difference_type
        j: std::list< std::string >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::list< std::string >::difference_type
        j: std::list< std::string >::difference_type
        v: std::list< std::string,std::allocator< std::string > > const &

        """
        return _pyBasePython.liststring___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::list< std::string >::difference_type
        j: std::list< std::string >::difference_type

        """
        return _pyBasePython.liststring___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::list< std::string >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.liststring___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> liststring

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> std::list< std::string >::value_type const &

        Parameters
        ----------
        i: std::list< std::string >::difference_type

        """
        return _pyBasePython.liststring___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::list< std::string,std::allocator< std::string > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::list< std::string >::difference_type
        x: std::list< std::string >::value_type const &

        """
        return _pyBasePython.liststring___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> std::list< std::string >::value_type"""
        return _pyBasePython.liststring_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::list< std::string >::value_type const &

        """
        return _pyBasePython.liststring_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.liststring_empty(self)

    def size(self):
        r"""size(self) -> std::list< std::string >::size_type"""
        return _pyBasePython.liststring_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::list< std::string > &

        """
        return _pyBasePython.liststring_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::list< std::string >::iterator"""
        return _pyBasePython.liststring_begin(self)

    def end(self):
        r"""end(self) -> std::list< std::string >::iterator"""
        return _pyBasePython.liststring_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::list< std::string >::reverse_iterator"""
        return _pyBasePython.liststring_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::list< std::string >::reverse_iterator"""
        return _pyBasePython.liststring_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.liststring_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::list< std::string >::allocator_type"""
        return _pyBasePython.liststring_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.liststring_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::list< std::string >::iterator

        Parameters
        ----------
        pos: std::list< std::string >::iterator

        erase(self, first, last) -> std::list< std::string >::iterator

        Parameters
        ----------
        first: std::list< std::string >::iterator
        last: std::list< std::string >::iterator

        """
        return _pyBasePython.liststring_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> liststring
        __init__(self, other) -> liststring

        Parameters
        ----------
        other: std::list< std::string > const &

        __init__(self, size) -> liststring

        Parameters
        ----------
        size: std::list< std::string >::size_type

        __init__(self, size, value) -> liststring

        Parameters
        ----------
        size: std::list< std::string >::size_type
        value: std::list< std::string >::value_type const &

        """
        _pyBasePython.liststring_swiginit(self, _pyBasePython.new_liststring(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::list< std::string >::value_type const &

        """
        return _pyBasePython.liststring_push_back(self, x)

    def front(self):
        r"""front(self) -> std::list< std::string >::value_type const &"""
        return _pyBasePython.liststring_front(self)

    def back(self):
        r"""back(self) -> std::list< std::string >::value_type const &"""
        return _pyBasePython.liststring_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::list< std::string >::size_type
        x: std::list< std::string >::value_type const &

        """
        return _pyBasePython.liststring_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::list< std::string >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::list< std::string >::size_type
        x: std::list< std::string >::value_type const &

        """
        return _pyBasePython.liststring_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::list< std::string >::iterator

        Parameters
        ----------
        pos: std::list< std::string >::iterator
        x: std::list< std::string >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::list< std::string >::iterator
        n: std::list< std::string >::size_type
        x: std::list< std::string >::value_type const &

        """
        return _pyBasePython.liststring_insert(self, *args)

    def pop_front(self):
        r"""pop_front(self)"""
        return _pyBasePython.liststring_pop_front(self)

    def push_front(self, x):
        r"""
        push_front(self, x)

        Parameters
        ----------
        x: std::list< std::string >::value_type const &

        """
        return _pyBasePython.liststring_push_front(self, x)

    def reverse(self):
        r"""reverse(self)"""
        return _pyBasePython.liststring_reverse(self)
    __swig_destroy__ = _pyBasePython.delete_liststring

# Register liststring in _pyBasePython:
_pyBasePython.liststring_swigregister(liststring)
class setB(collections.abc.MutableSet if _swig_python_version_info >= (3, 3) else collections.MutableSet):
    r"""Proxy of C++ std::set< bool,std::less< bool > > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.setB_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.setB___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.setB___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::set< bool,std::less< bool > >::size_type"""
        return _pyBasePython.setB___len__(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::set< bool,std::less< bool > >::value_type

        """
        return _pyBasePython.setB_append(self, x)

    def __contains__(self, x):
        r"""
        __contains__(self, x) -> bool

        Parameters
        ----------
        x: std::set< bool,std::less< bool > >::value_type

        """
        return _pyBasePython.setB___contains__(self, x)

    def __getitem__(self, i):
        r"""
        __getitem__(self, i) -> std::set< bool,std::less< bool > >::value_type

        Parameters
        ----------
        i: std::set< bool,std::less< bool > >::difference_type

        """
        return _pyBasePython.setB___getitem__(self, i)

    def add(self, x):
        r"""
        add(self, x)

        Parameters
        ----------
        x: std::set< bool,std::less< bool > >::value_type

        """
        return _pyBasePython.setB_add(self, x)

    def discard(self, x):
        r"""
        discard(self, x)

        Parameters
        ----------
        x: std::set< bool,std::less< bool > >::value_type

        """
        return _pyBasePython.setB_discard(self, x)

    def __init__(self, *args):
        r"""
        __init__(self, other) -> setB

        Parameters
        ----------
        other: std::less< bool > const &

        __init__(self) -> setB
        __init__(self, other) -> setB

        Parameters
        ----------
        other: std::set< bool,std::less< bool > > const &

        """
        _pyBasePython.setB_swiginit(self, _pyBasePython.new_setB(*args))

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.setB_empty(self)

    def size(self):
        r"""size(self) -> std::set< bool,std::less< bool > >::size_type"""
        return _pyBasePython.setB_size(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.setB_clear(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::set< bool,std::less< bool > > &

        """
        return _pyBasePython.setB_swap(self, v)

    def count(self, x):
        r"""
        count(self, x) -> std::set< bool,std::less< bool > >::size_type

        Parameters
        ----------
        x: std::set< bool,std::less< bool > >::key_type const &

        """
        return _pyBasePython.setB_count(self, x)

    def begin(self):
        r"""begin(self) -> std::set< bool,std::less< bool > >::iterator"""
        return _pyBasePython.setB_begin(self)

    def end(self):
        r"""end(self) -> std::set< bool,std::less< bool > >::iterator"""
        return _pyBasePython.setB_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::set< bool,std::less< bool > >::reverse_iterator"""
        return _pyBasePython.setB_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::set< bool,std::less< bool > >::reverse_iterator"""
        return _pyBasePython.setB_rend(self)

    def erase(self, *args):
        r"""
        erase(self, x) -> std::set< bool,std::less< bool > >::size_type

        Parameters
        ----------
        x: std::set< bool,std::less< bool > >::key_type const &

        erase(self, pos)

        Parameters
        ----------
        pos: std::set< bool,std::less< bool > >::iterator

        erase(self, first, last)

        Parameters
        ----------
        first: std::set< bool,std::less< bool > >::iterator
        last: std::set< bool,std::less< bool > >::iterator

        """
        return _pyBasePython.setB_erase(self, *args)

    def find(self, x):
        r"""
        find(self, x) -> std::set< bool,std::less< bool > >::iterator

        Parameters
        ----------
        x: std::set< bool,std::less< bool > >::key_type const &

        """
        return _pyBasePython.setB_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(self, x) -> std::set< bool,std::less< bool > >::iterator

        Parameters
        ----------
        x: std::set< bool,std::less< bool > >::key_type const &

        """
        return _pyBasePython.setB_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(self, x) -> std::set< bool,std::less< bool > >::iterator

        Parameters
        ----------
        x: std::set< bool,std::less< bool > >::key_type const &

        """
        return _pyBasePython.setB_upper_bound(self, x)

    def equal_range(self, x):
        r"""
        equal_range(self, x) -> std::pair< std::set< bool,std::less< bool > >::iterator,std::set< bool,std::less< bool > >::iterator >

        Parameters
        ----------
        x: std::set< bool,std::less< bool > >::key_type const &

        """
        return _pyBasePython.setB_equal_range(self, x)

    def insert(self, __x):
        r"""
        insert(self, __x) -> std::pair< std::set< bool,std::less< bool > >::iterator,bool >

        Parameters
        ----------
        __x: std::set< bool,std::less< bool > >::value_type const &

        """
        return _pyBasePython.setB_insert(self, __x)
    __swig_destroy__ = _pyBasePython.delete_setB

# Register setB in _pyBasePython:
_pyBasePython.setB_swigregister(setB)
class setI(collections.abc.MutableSet if _swig_python_version_info >= (3, 3) else collections.MutableSet):
    r"""Proxy of C++ std::set< int,std::less< int > > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.setI_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.setI___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.setI___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::set< int,std::less< int > >::size_type"""
        return _pyBasePython.setI___len__(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::set< int,std::less< int > >::value_type

        """
        return _pyBasePython.setI_append(self, x)

    def __contains__(self, x):
        r"""
        __contains__(self, x) -> bool

        Parameters
        ----------
        x: std::set< int,std::less< int > >::value_type

        """
        return _pyBasePython.setI___contains__(self, x)

    def __getitem__(self, i):
        r"""
        __getitem__(self, i) -> std::set< int,std::less< int > >::value_type

        Parameters
        ----------
        i: std::set< int,std::less< int > >::difference_type

        """
        return _pyBasePython.setI___getitem__(self, i)

    def add(self, x):
        r"""
        add(self, x)

        Parameters
        ----------
        x: std::set< int,std::less< int > >::value_type

        """
        return _pyBasePython.setI_add(self, x)

    def discard(self, x):
        r"""
        discard(self, x)

        Parameters
        ----------
        x: std::set< int,std::less< int > >::value_type

        """
        return _pyBasePython.setI_discard(self, x)

    def __init__(self, *args):
        r"""
        __init__(self, other) -> setI

        Parameters
        ----------
        other: std::less< int > const &

        __init__(self) -> setI
        __init__(self, other) -> setI

        Parameters
        ----------
        other: std::set< int,std::less< int > > const &

        """
        _pyBasePython.setI_swiginit(self, _pyBasePython.new_setI(*args))

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.setI_empty(self)

    def size(self):
        r"""size(self) -> std::set< int,std::less< int > >::size_type"""
        return _pyBasePython.setI_size(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.setI_clear(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::set< int,std::less< int > > &

        """
        return _pyBasePython.setI_swap(self, v)

    def count(self, x):
        r"""
        count(self, x) -> std::set< int,std::less< int > >::size_type

        Parameters
        ----------
        x: std::set< int,std::less< int > >::key_type const &

        """
        return _pyBasePython.setI_count(self, x)

    def begin(self):
        r"""begin(self) -> std::set< int,std::less< int > >::iterator"""
        return _pyBasePython.setI_begin(self)

    def end(self):
        r"""end(self) -> std::set< int,std::less< int > >::iterator"""
        return _pyBasePython.setI_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::set< int,std::less< int > >::reverse_iterator"""
        return _pyBasePython.setI_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::set< int,std::less< int > >::reverse_iterator"""
        return _pyBasePython.setI_rend(self)

    def erase(self, *args):
        r"""
        erase(self, x) -> std::set< int,std::less< int > >::size_type

        Parameters
        ----------
        x: std::set< int,std::less< int > >::key_type const &

        erase(self, pos)

        Parameters
        ----------
        pos: std::set< int,std::less< int > >::iterator

        erase(self, first, last)

        Parameters
        ----------
        first: std::set< int,std::less< int > >::iterator
        last: std::set< int,std::less< int > >::iterator

        """
        return _pyBasePython.setI_erase(self, *args)

    def find(self, x):
        r"""
        find(self, x) -> std::set< int,std::less< int > >::iterator

        Parameters
        ----------
        x: std::set< int,std::less< int > >::key_type const &

        """
        return _pyBasePython.setI_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(self, x) -> std::set< int,std::less< int > >::iterator

        Parameters
        ----------
        x: std::set< int,std::less< int > >::key_type const &

        """
        return _pyBasePython.setI_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(self, x) -> std::set< int,std::less< int > >::iterator

        Parameters
        ----------
        x: std::set< int,std::less< int > >::key_type const &

        """
        return _pyBasePython.setI_upper_bound(self, x)

    def equal_range(self, x):
        r"""
        equal_range(self, x) -> std::pair< std::set< int,std::less< int > >::iterator,std::set< int,std::less< int > >::iterator >

        Parameters
        ----------
        x: std::set< int,std::less< int > >::key_type const &

        """
        return _pyBasePython.setI_equal_range(self, x)

    def insert(self, __x):
        r"""
        insert(self, __x) -> std::pair< std::set< int,std::less< int > >::iterator,bool >

        Parameters
        ----------
        __x: std::set< int,std::less< int > >::value_type const &

        """
        return _pyBasePython.setI_insert(self, __x)
    __swig_destroy__ = _pyBasePython.delete_setI

# Register setI in _pyBasePython:
_pyBasePython.setI_swigregister(setI)
class setUC(collections.abc.MutableSet if _swig_python_version_info >= (3, 3) else collections.MutableSet):
    r"""Proxy of C++ std::set< unsigned char,std::less< unsigned char > > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.setUC_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.setUC___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.setUC___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::set< unsigned char,std::less< unsigned char > >::size_type"""
        return _pyBasePython.setUC___len__(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::set< unsigned char,std::less< unsigned char > >::value_type

        """
        return _pyBasePython.setUC_append(self, x)

    def __contains__(self, x):
        r"""
        __contains__(self, x) -> bool

        Parameters
        ----------
        x: std::set< unsigned char,std::less< unsigned char > >::value_type

        """
        return _pyBasePython.setUC___contains__(self, x)

    def __getitem__(self, i):
        r"""
        __getitem__(self, i) -> std::set< unsigned char,std::less< unsigned char > >::value_type

        Parameters
        ----------
        i: std::set< unsigned char,std::less< unsigned char > >::difference_type

        """
        return _pyBasePython.setUC___getitem__(self, i)

    def add(self, x):
        r"""
        add(self, x)

        Parameters
        ----------
        x: std::set< unsigned char,std::less< unsigned char > >::value_type

        """
        return _pyBasePython.setUC_add(self, x)

    def discard(self, x):
        r"""
        discard(self, x)

        Parameters
        ----------
        x: std::set< unsigned char,std::less< unsigned char > >::value_type

        """
        return _pyBasePython.setUC_discard(self, x)

    def __init__(self, *args):
        r"""
        __init__(self, other) -> setUC

        Parameters
        ----------
        other: std::less< unsigned char > const &

        __init__(self) -> setUC
        __init__(self, other) -> setUC

        Parameters
        ----------
        other: std::set< unsigned char,std::less< unsigned char > > const &

        """
        _pyBasePython.setUC_swiginit(self, _pyBasePython.new_setUC(*args))

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.setUC_empty(self)

    def size(self):
        r"""size(self) -> std::set< unsigned char,std::less< unsigned char > >::size_type"""
        return _pyBasePython.setUC_size(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.setUC_clear(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::set< unsigned char,std::less< unsigned char > > &

        """
        return _pyBasePython.setUC_swap(self, v)

    def count(self, x):
        r"""
        count(self, x) -> std::set< unsigned char,std::less< unsigned char > >::size_type

        Parameters
        ----------
        x: std::set< unsigned char,std::less< unsigned char > >::key_type const &

        """
        return _pyBasePython.setUC_count(self, x)

    def begin(self):
        r"""begin(self) -> std::set< unsigned char,std::less< unsigned char > >::iterator"""
        return _pyBasePython.setUC_begin(self)

    def end(self):
        r"""end(self) -> std::set< unsigned char,std::less< unsigned char > >::iterator"""
        return _pyBasePython.setUC_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::set< unsigned char,std::less< unsigned char > >::reverse_iterator"""
        return _pyBasePython.setUC_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::set< unsigned char,std::less< unsigned char > >::reverse_iterator"""
        return _pyBasePython.setUC_rend(self)

    def erase(self, *args):
        r"""
        erase(self, x) -> std::set< unsigned char,std::less< unsigned char > >::size_type

        Parameters
        ----------
        x: std::set< unsigned char,std::less< unsigned char > >::key_type const &

        erase(self, pos)

        Parameters
        ----------
        pos: std::set< unsigned char,std::less< unsigned char > >::iterator

        erase(self, first, last)

        Parameters
        ----------
        first: std::set< unsigned char,std::less< unsigned char > >::iterator
        last: std::set< unsigned char,std::less< unsigned char > >::iterator

        """
        return _pyBasePython.setUC_erase(self, *args)

    def find(self, x):
        r"""
        find(self, x) -> std::set< unsigned char,std::less< unsigned char > >::iterator

        Parameters
        ----------
        x: std::set< unsigned char,std::less< unsigned char > >::key_type const &

        """
        return _pyBasePython.setUC_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(self, x) -> std::set< unsigned char,std::less< unsigned char > >::iterator

        Parameters
        ----------
        x: std::set< unsigned char,std::less< unsigned char > >::key_type const &

        """
        return _pyBasePython.setUC_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(self, x) -> std::set< unsigned char,std::less< unsigned char > >::iterator

        Parameters
        ----------
        x: std::set< unsigned char,std::less< unsigned char > >::key_type const &

        """
        return _pyBasePython.setUC_upper_bound(self, x)

    def equal_range(self, x):
        r"""
        equal_range(self, x) -> std::pair< std::set< unsigned char,std::less< unsigned char > >::iterator,std::set< unsigned char,std::less< unsigned char > >::iterator >

        Parameters
        ----------
        x: std::set< unsigned char,std::less< unsigned char > >::key_type const &

        """
        return _pyBasePython.setUC_equal_range(self, x)

    def insert(self, __x):
        r"""
        insert(self, __x) -> std::pair< std::set< unsigned char,std::less< unsigned char > >::iterator,bool >

        Parameters
        ----------
        __x: std::set< unsigned char,std::less< unsigned char > >::value_type const &

        """
        return _pyBasePython.setUC_insert(self, __x)
    __swig_destroy__ = _pyBasePython.delete_setUC

# Register setUC in _pyBasePython:
_pyBasePython.setUC_swigregister(setUC)
class setUS(collections.abc.MutableSet if _swig_python_version_info >= (3, 3) else collections.MutableSet):
    r"""Proxy of C++ std::set< unsigned short,std::less< unsigned short > > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.setUS_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.setUS___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.setUS___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::set< unsigned short,std::less< unsigned short > >::size_type"""
        return _pyBasePython.setUS___len__(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::set< unsigned short,std::less< unsigned short > >::value_type

        """
        return _pyBasePython.setUS_append(self, x)

    def __contains__(self, x):
        r"""
        __contains__(self, x) -> bool

        Parameters
        ----------
        x: std::set< unsigned short,std::less< unsigned short > >::value_type

        """
        return _pyBasePython.setUS___contains__(self, x)

    def __getitem__(self, i):
        r"""
        __getitem__(self, i) -> std::set< unsigned short,std::less< unsigned short > >::value_type

        Parameters
        ----------
        i: std::set< unsigned short,std::less< unsigned short > >::difference_type

        """
        return _pyBasePython.setUS___getitem__(self, i)

    def add(self, x):
        r"""
        add(self, x)

        Parameters
        ----------
        x: std::set< unsigned short,std::less< unsigned short > >::value_type

        """
        return _pyBasePython.setUS_add(self, x)

    def discard(self, x):
        r"""
        discard(self, x)

        Parameters
        ----------
        x: std::set< unsigned short,std::less< unsigned short > >::value_type

        """
        return _pyBasePython.setUS_discard(self, x)

    def __init__(self, *args):
        r"""
        __init__(self, other) -> setUS

        Parameters
        ----------
        other: std::less< unsigned short > const &

        __init__(self) -> setUS
        __init__(self, other) -> setUS

        Parameters
        ----------
        other: std::set< unsigned short,std::less< unsigned short > > const &

        """
        _pyBasePython.setUS_swiginit(self, _pyBasePython.new_setUS(*args))

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.setUS_empty(self)

    def size(self):
        r"""size(self) -> std::set< unsigned short,std::less< unsigned short > >::size_type"""
        return _pyBasePython.setUS_size(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.setUS_clear(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::set< unsigned short,std::less< unsigned short > > &

        """
        return _pyBasePython.setUS_swap(self, v)

    def count(self, x):
        r"""
        count(self, x) -> std::set< unsigned short,std::less< unsigned short > >::size_type

        Parameters
        ----------
        x: std::set< unsigned short,std::less< unsigned short > >::key_type const &

        """
        return _pyBasePython.setUS_count(self, x)

    def begin(self):
        r"""begin(self) -> std::set< unsigned short,std::less< unsigned short > >::iterator"""
        return _pyBasePython.setUS_begin(self)

    def end(self):
        r"""end(self) -> std::set< unsigned short,std::less< unsigned short > >::iterator"""
        return _pyBasePython.setUS_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::set< unsigned short,std::less< unsigned short > >::reverse_iterator"""
        return _pyBasePython.setUS_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::set< unsigned short,std::less< unsigned short > >::reverse_iterator"""
        return _pyBasePython.setUS_rend(self)

    def erase(self, *args):
        r"""
        erase(self, x) -> std::set< unsigned short,std::less< unsigned short > >::size_type

        Parameters
        ----------
        x: std::set< unsigned short,std::less< unsigned short > >::key_type const &

        erase(self, pos)

        Parameters
        ----------
        pos: std::set< unsigned short,std::less< unsigned short > >::iterator

        erase(self, first, last)

        Parameters
        ----------
        first: std::set< unsigned short,std::less< unsigned short > >::iterator
        last: std::set< unsigned short,std::less< unsigned short > >::iterator

        """
        return _pyBasePython.setUS_erase(self, *args)

    def find(self, x):
        r"""
        find(self, x) -> std::set< unsigned short,std::less< unsigned short > >::iterator

        Parameters
        ----------
        x: std::set< unsigned short,std::less< unsigned short > >::key_type const &

        """
        return _pyBasePython.setUS_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(self, x) -> std::set< unsigned short,std::less< unsigned short > >::iterator

        Parameters
        ----------
        x: std::set< unsigned short,std::less< unsigned short > >::key_type const &

        """
        return _pyBasePython.setUS_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(self, x) -> std::set< unsigned short,std::less< unsigned short > >::iterator

        Parameters
        ----------
        x: std::set< unsigned short,std::less< unsigned short > >::key_type const &

        """
        return _pyBasePython.setUS_upper_bound(self, x)

    def equal_range(self, x):
        r"""
        equal_range(self, x) -> std::pair< std::set< unsigned short,std::less< unsigned short > >::iterator,std::set< unsigned short,std::less< unsigned short > >::iterator >

        Parameters
        ----------
        x: std::set< unsigned short,std::less< unsigned short > >::key_type const &

        """
        return _pyBasePython.setUS_equal_range(self, x)

    def insert(self, __x):
        r"""
        insert(self, __x) -> std::pair< std::set< unsigned short,std::less< unsigned short > >::iterator,bool >

        Parameters
        ----------
        __x: std::set< unsigned short,std::less< unsigned short > >::value_type const &

        """
        return _pyBasePython.setUS_insert(self, __x)
    __swig_destroy__ = _pyBasePython.delete_setUS

# Register setUS in _pyBasePython:
_pyBasePython.setUS_swigregister(setUS)
class setUI(collections.abc.MutableSet if _swig_python_version_info >= (3, 3) else collections.MutableSet):
    r"""Proxy of C++ std::set< unsigned int,std::less< unsigned int > > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.setUI_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.setUI___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.setUI___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::set< unsigned int,std::less< unsigned int > >::size_type"""
        return _pyBasePython.setUI___len__(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::set< unsigned int,std::less< unsigned int > >::value_type

        """
        return _pyBasePython.setUI_append(self, x)

    def __contains__(self, x):
        r"""
        __contains__(self, x) -> bool

        Parameters
        ----------
        x: std::set< unsigned int,std::less< unsigned int > >::value_type

        """
        return _pyBasePython.setUI___contains__(self, x)

    def __getitem__(self, i):
        r"""
        __getitem__(self, i) -> std::set< unsigned int,std::less< unsigned int > >::value_type

        Parameters
        ----------
        i: std::set< unsigned int,std::less< unsigned int > >::difference_type

        """
        return _pyBasePython.setUI___getitem__(self, i)

    def add(self, x):
        r"""
        add(self, x)

        Parameters
        ----------
        x: std::set< unsigned int,std::less< unsigned int > >::value_type

        """
        return _pyBasePython.setUI_add(self, x)

    def discard(self, x):
        r"""
        discard(self, x)

        Parameters
        ----------
        x: std::set< unsigned int,std::less< unsigned int > >::value_type

        """
        return _pyBasePython.setUI_discard(self, x)

    def __init__(self, *args):
        r"""
        __init__(self, other) -> setUI

        Parameters
        ----------
        other: std::less< unsigned int > const &

        __init__(self) -> setUI
        __init__(self, other) -> setUI

        Parameters
        ----------
        other: std::set< unsigned int,std::less< unsigned int > > const &

        """
        _pyBasePython.setUI_swiginit(self, _pyBasePython.new_setUI(*args))

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.setUI_empty(self)

    def size(self):
        r"""size(self) -> std::set< unsigned int,std::less< unsigned int > >::size_type"""
        return _pyBasePython.setUI_size(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.setUI_clear(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::set< unsigned int,std::less< unsigned int > > &

        """
        return _pyBasePython.setUI_swap(self, v)

    def count(self, x):
        r"""
        count(self, x) -> std::set< unsigned int,std::less< unsigned int > >::size_type

        Parameters
        ----------
        x: std::set< unsigned int,std::less< unsigned int > >::key_type const &

        """
        return _pyBasePython.setUI_count(self, x)

    def begin(self):
        r"""begin(self) -> std::set< unsigned int,std::less< unsigned int > >::iterator"""
        return _pyBasePython.setUI_begin(self)

    def end(self):
        r"""end(self) -> std::set< unsigned int,std::less< unsigned int > >::iterator"""
        return _pyBasePython.setUI_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::set< unsigned int,std::less< unsigned int > >::reverse_iterator"""
        return _pyBasePython.setUI_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::set< unsigned int,std::less< unsigned int > >::reverse_iterator"""
        return _pyBasePython.setUI_rend(self)

    def erase(self, *args):
        r"""
        erase(self, x) -> std::set< unsigned int,std::less< unsigned int > >::size_type

        Parameters
        ----------
        x: std::set< unsigned int,std::less< unsigned int > >::key_type const &

        erase(self, pos)

        Parameters
        ----------
        pos: std::set< unsigned int,std::less< unsigned int > >::iterator

        erase(self, first, last)

        Parameters
        ----------
        first: std::set< unsigned int,std::less< unsigned int > >::iterator
        last: std::set< unsigned int,std::less< unsigned int > >::iterator

        """
        return _pyBasePython.setUI_erase(self, *args)

    def find(self, x):
        r"""
        find(self, x) -> std::set< unsigned int,std::less< unsigned int > >::iterator

        Parameters
        ----------
        x: std::set< unsigned int,std::less< unsigned int > >::key_type const &

        """
        return _pyBasePython.setUI_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(self, x) -> std::set< unsigned int,std::less< unsigned int > >::iterator

        Parameters
        ----------
        x: std::set< unsigned int,std::less< unsigned int > >::key_type const &

        """
        return _pyBasePython.setUI_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(self, x) -> std::set< unsigned int,std::less< unsigned int > >::iterator

        Parameters
        ----------
        x: std::set< unsigned int,std::less< unsigned int > >::key_type const &

        """
        return _pyBasePython.setUI_upper_bound(self, x)

    def equal_range(self, x):
        r"""
        equal_range(self, x) -> std::pair< std::set< unsigned int,std::less< unsigned int > >::iterator,std::set< unsigned int,std::less< unsigned int > >::iterator >

        Parameters
        ----------
        x: std::set< unsigned int,std::less< unsigned int > >::key_type const &

        """
        return _pyBasePython.setUI_equal_range(self, x)

    def insert(self, __x):
        r"""
        insert(self, __x) -> std::pair< std::set< unsigned int,std::less< unsigned int > >::iterator,bool >

        Parameters
        ----------
        __x: std::set< unsigned int,std::less< unsigned int > >::value_type const &

        """
        return _pyBasePython.setUI_insert(self, __x)
    __swig_destroy__ = _pyBasePython.delete_setUI

# Register setUI in _pyBasePython:
_pyBasePython.setUI_swigregister(setUI)
class setUL(collections.abc.MutableSet if _swig_python_version_info >= (3, 3) else collections.MutableSet):
    r"""Proxy of C++ std::set< unsigned long,std::less< unsigned long > > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.setUL_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.setUL___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.setUL___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::set< unsigned long,std::less< unsigned long > >::size_type"""
        return _pyBasePython.setUL___len__(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::set< unsigned long,std::less< unsigned long > >::value_type

        """
        return _pyBasePython.setUL_append(self, x)

    def __contains__(self, x):
        r"""
        __contains__(self, x) -> bool

        Parameters
        ----------
        x: std::set< unsigned long,std::less< unsigned long > >::value_type

        """
        return _pyBasePython.setUL___contains__(self, x)

    def __getitem__(self, i):
        r"""
        __getitem__(self, i) -> std::set< unsigned long,std::less< unsigned long > >::value_type

        Parameters
        ----------
        i: std::set< unsigned long,std::less< unsigned long > >::difference_type

        """
        return _pyBasePython.setUL___getitem__(self, i)

    def add(self, x):
        r"""
        add(self, x)

        Parameters
        ----------
        x: std::set< unsigned long,std::less< unsigned long > >::value_type

        """
        return _pyBasePython.setUL_add(self, x)

    def discard(self, x):
        r"""
        discard(self, x)

        Parameters
        ----------
        x: std::set< unsigned long,std::less< unsigned long > >::value_type

        """
        return _pyBasePython.setUL_discard(self, x)

    def __init__(self, *args):
        r"""
        __init__(self, other) -> setUL

        Parameters
        ----------
        other: std::less< unsigned long > const &

        __init__(self) -> setUL
        __init__(self, other) -> setUL

        Parameters
        ----------
        other: std::set< unsigned long,std::less< unsigned long > > const &

        """
        _pyBasePython.setUL_swiginit(self, _pyBasePython.new_setUL(*args))

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.setUL_empty(self)

    def size(self):
        r"""size(self) -> std::set< unsigned long,std::less< unsigned long > >::size_type"""
        return _pyBasePython.setUL_size(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.setUL_clear(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::set< unsigned long,std::less< unsigned long > > &

        """
        return _pyBasePython.setUL_swap(self, v)

    def count(self, x):
        r"""
        count(self, x) -> std::set< unsigned long,std::less< unsigned long > >::size_type

        Parameters
        ----------
        x: std::set< unsigned long,std::less< unsigned long > >::key_type const &

        """
        return _pyBasePython.setUL_count(self, x)

    def begin(self):
        r"""begin(self) -> std::set< unsigned long,std::less< unsigned long > >::iterator"""
        return _pyBasePython.setUL_begin(self)

    def end(self):
        r"""end(self) -> std::set< unsigned long,std::less< unsigned long > >::iterator"""
        return _pyBasePython.setUL_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::set< unsigned long,std::less< unsigned long > >::reverse_iterator"""
        return _pyBasePython.setUL_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::set< unsigned long,std::less< unsigned long > >::reverse_iterator"""
        return _pyBasePython.setUL_rend(self)

    def erase(self, *args):
        r"""
        erase(self, x) -> std::set< unsigned long,std::less< unsigned long > >::size_type

        Parameters
        ----------
        x: std::set< unsigned long,std::less< unsigned long > >::key_type const &

        erase(self, pos)

        Parameters
        ----------
        pos: std::set< unsigned long,std::less< unsigned long > >::iterator

        erase(self, first, last)

        Parameters
        ----------
        first: std::set< unsigned long,std::less< unsigned long > >::iterator
        last: std::set< unsigned long,std::less< unsigned long > >::iterator

        """
        return _pyBasePython.setUL_erase(self, *args)

    def find(self, x):
        r"""
        find(self, x) -> std::set< unsigned long,std::less< unsigned long > >::iterator

        Parameters
        ----------
        x: std::set< unsigned long,std::less< unsigned long > >::key_type const &

        """
        return _pyBasePython.setUL_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(self, x) -> std::set< unsigned long,std::less< unsigned long > >::iterator

        Parameters
        ----------
        x: std::set< unsigned long,std::less< unsigned long > >::key_type const &

        """
        return _pyBasePython.setUL_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(self, x) -> std::set< unsigned long,std::less< unsigned long > >::iterator

        Parameters
        ----------
        x: std::set< unsigned long,std::less< unsigned long > >::key_type const &

        """
        return _pyBasePython.setUL_upper_bound(self, x)

    def equal_range(self, x):
        r"""
        equal_range(self, x) -> std::pair< std::set< unsigned long,std::less< unsigned long > >::iterator,std::set< unsigned long,std::less< unsigned long > >::iterator >

        Parameters
        ----------
        x: std::set< unsigned long,std::less< unsigned long > >::key_type const &

        """
        return _pyBasePython.setUL_equal_range(self, x)

    def insert(self, __x):
        r"""
        insert(self, __x) -> std::pair< std::set< unsigned long,std::less< unsigned long > >::iterator,bool >

        Parameters
        ----------
        __x: std::set< unsigned long,std::less< unsigned long > >::value_type const &

        """
        return _pyBasePython.setUL_insert(self, __x)
    __swig_destroy__ = _pyBasePython.delete_setUL

# Register setUL in _pyBasePython:
_pyBasePython.setUL_swigregister(setUL)
class setULL(collections.abc.MutableSet if _swig_python_version_info >= (3, 3) else collections.MutableSet):
    r"""Proxy of C++ std::set< unsigned long long,std::less< unsigned long long > > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.setULL_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.setULL___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.setULL___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::set< unsigned long long,std::less< unsigned long long > >::size_type"""
        return _pyBasePython.setULL___len__(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::set< unsigned long long,std::less< unsigned long long > >::value_type

        """
        return _pyBasePython.setULL_append(self, x)

    def __contains__(self, x):
        r"""
        __contains__(self, x) -> bool

        Parameters
        ----------
        x: std::set< unsigned long long,std::less< unsigned long long > >::value_type

        """
        return _pyBasePython.setULL___contains__(self, x)

    def __getitem__(self, i):
        r"""
        __getitem__(self, i) -> std::set< unsigned long long,std::less< unsigned long long > >::value_type

        Parameters
        ----------
        i: std::set< unsigned long long,std::less< unsigned long long > >::difference_type

        """
        return _pyBasePython.setULL___getitem__(self, i)

    def add(self, x):
        r"""
        add(self, x)

        Parameters
        ----------
        x: std::set< unsigned long long,std::less< unsigned long long > >::value_type

        """
        return _pyBasePython.setULL_add(self, x)

    def discard(self, x):
        r"""
        discard(self, x)

        Parameters
        ----------
        x: std::set< unsigned long long,std::less< unsigned long long > >::value_type

        """
        return _pyBasePython.setULL_discard(self, x)

    def __init__(self, *args):
        r"""
        __init__(self, other) -> setULL

        Parameters
        ----------
        other: std::less< unsigned long long > const &

        __init__(self) -> setULL
        __init__(self, other) -> setULL

        Parameters
        ----------
        other: std::set< unsigned long long,std::less< unsigned long long > > const &

        """
        _pyBasePython.setULL_swiginit(self, _pyBasePython.new_setULL(*args))

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.setULL_empty(self)

    def size(self):
        r"""size(self) -> std::set< unsigned long long,std::less< unsigned long long > >::size_type"""
        return _pyBasePython.setULL_size(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.setULL_clear(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::set< unsigned long long,std::less< unsigned long long > > &

        """
        return _pyBasePython.setULL_swap(self, v)

    def count(self, x):
        r"""
        count(self, x) -> std::set< unsigned long long,std::less< unsigned long long > >::size_type

        Parameters
        ----------
        x: std::set< unsigned long long,std::less< unsigned long long > >::key_type const &

        """
        return _pyBasePython.setULL_count(self, x)

    def begin(self):
        r"""begin(self) -> std::set< unsigned long long,std::less< unsigned long long > >::iterator"""
        return _pyBasePython.setULL_begin(self)

    def end(self):
        r"""end(self) -> std::set< unsigned long long,std::less< unsigned long long > >::iterator"""
        return _pyBasePython.setULL_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::set< unsigned long long,std::less< unsigned long long > >::reverse_iterator"""
        return _pyBasePython.setULL_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::set< unsigned long long,std::less< unsigned long long > >::reverse_iterator"""
        return _pyBasePython.setULL_rend(self)

    def erase(self, *args):
        r"""
        erase(self, x) -> std::set< unsigned long long,std::less< unsigned long long > >::size_type

        Parameters
        ----------
        x: std::set< unsigned long long,std::less< unsigned long long > >::key_type const &

        erase(self, pos)

        Parameters
        ----------
        pos: std::set< unsigned long long,std::less< unsigned long long > >::iterator

        erase(self, first, last)

        Parameters
        ----------
        first: std::set< unsigned long long,std::less< unsigned long long > >::iterator
        last: std::set< unsigned long long,std::less< unsigned long long > >::iterator

        """
        return _pyBasePython.setULL_erase(self, *args)

    def find(self, x):
        r"""
        find(self, x) -> std::set< unsigned long long,std::less< unsigned long long > >::iterator

        Parameters
        ----------
        x: std::set< unsigned long long,std::less< unsigned long long > >::key_type const &

        """
        return _pyBasePython.setULL_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(self, x) -> std::set< unsigned long long,std::less< unsigned long long > >::iterator

        Parameters
        ----------
        x: std::set< unsigned long long,std::less< unsigned long long > >::key_type const &

        """
        return _pyBasePython.setULL_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(self, x) -> std::set< unsigned long long,std::less< unsigned long long > >::iterator

        Parameters
        ----------
        x: std::set< unsigned long long,std::less< unsigned long long > >::key_type const &

        """
        return _pyBasePython.setULL_upper_bound(self, x)

    def equal_range(self, x):
        r"""
        equal_range(self, x) -> std::pair< std::set< unsigned long long,std::less< unsigned long long > >::iterator,std::set< unsigned long long,std::less< unsigned long long > >::iterator >

        Parameters
        ----------
        x: std::set< unsigned long long,std::less< unsigned long long > >::key_type const &

        """
        return _pyBasePython.setULL_equal_range(self, x)

    def insert(self, __x):
        r"""
        insert(self, __x) -> std::pair< std::set< unsigned long long,std::less< unsigned long long > >::iterator,bool >

        Parameters
        ----------
        __x: std::set< unsigned long long,std::less< unsigned long long > >::value_type const &

        """
        return _pyBasePython.setULL_insert(self, __x)
    __swig_destroy__ = _pyBasePython.delete_setULL

# Register setULL in _pyBasePython:
_pyBasePython.setULL_swigregister(setULL)
class setSC(collections.abc.MutableSet if _swig_python_version_info >= (3, 3) else collections.MutableSet):
    r"""Proxy of C++ std::set< signed char,std::less< signed char > > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.setSC_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.setSC___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.setSC___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::set< signed char,std::less< signed char > >::size_type"""
        return _pyBasePython.setSC___len__(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::set< signed char,std::less< signed char > >::value_type

        """
        return _pyBasePython.setSC_append(self, x)

    def __contains__(self, x):
        r"""
        __contains__(self, x) -> bool

        Parameters
        ----------
        x: std::set< signed char,std::less< signed char > >::value_type

        """
        return _pyBasePython.setSC___contains__(self, x)

    def __getitem__(self, i):
        r"""
        __getitem__(self, i) -> std::set< signed char,std::less< signed char > >::value_type

        Parameters
        ----------
        i: std::set< signed char,std::less< signed char > >::difference_type

        """
        return _pyBasePython.setSC___getitem__(self, i)

    def add(self, x):
        r"""
        add(self, x)

        Parameters
        ----------
        x: std::set< signed char,std::less< signed char > >::value_type

        """
        return _pyBasePython.setSC_add(self, x)

    def discard(self, x):
        r"""
        discard(self, x)

        Parameters
        ----------
        x: std::set< signed char,std::less< signed char > >::value_type

        """
        return _pyBasePython.setSC_discard(self, x)

    def __init__(self, *args):
        r"""
        __init__(self, other) -> setSC

        Parameters
        ----------
        other: std::less< signed char > const &

        __init__(self) -> setSC
        __init__(self, other) -> setSC

        Parameters
        ----------
        other: std::set< signed char,std::less< signed char > > const &

        """
        _pyBasePython.setSC_swiginit(self, _pyBasePython.new_setSC(*args))

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.setSC_empty(self)

    def size(self):
        r"""size(self) -> std::set< signed char,std::less< signed char > >::size_type"""
        return _pyBasePython.setSC_size(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.setSC_clear(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::set< signed char,std::less< signed char > > &

        """
        return _pyBasePython.setSC_swap(self, v)

    def count(self, x):
        r"""
        count(self, x) -> std::set< signed char,std::less< signed char > >::size_type

        Parameters
        ----------
        x: std::set< signed char,std::less< signed char > >::key_type const &

        """
        return _pyBasePython.setSC_count(self, x)

    def begin(self):
        r"""begin(self) -> std::set< signed char,std::less< signed char > >::iterator"""
        return _pyBasePython.setSC_begin(self)

    def end(self):
        r"""end(self) -> std::set< signed char,std::less< signed char > >::iterator"""
        return _pyBasePython.setSC_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::set< signed char,std::less< signed char > >::reverse_iterator"""
        return _pyBasePython.setSC_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::set< signed char,std::less< signed char > >::reverse_iterator"""
        return _pyBasePython.setSC_rend(self)

    def erase(self, *args):
        r"""
        erase(self, x) -> std::set< signed char,std::less< signed char > >::size_type

        Parameters
        ----------
        x: std::set< signed char,std::less< signed char > >::key_type const &

        erase(self, pos)

        Parameters
        ----------
        pos: std::set< signed char,std::less< signed char > >::iterator

        erase(self, first, last)

        Parameters
        ----------
        first: std::set< signed char,std::less< signed char > >::iterator
        last: std::set< signed char,std::less< signed char > >::iterator

        """
        return _pyBasePython.setSC_erase(self, *args)

    def find(self, x):
        r"""
        find(self, x) -> std::set< signed char,std::less< signed char > >::iterator

        Parameters
        ----------
        x: std::set< signed char,std::less< signed char > >::key_type const &

        """
        return _pyBasePython.setSC_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(self, x) -> std::set< signed char,std::less< signed char > >::iterator

        Parameters
        ----------
        x: std::set< signed char,std::less< signed char > >::key_type const &

        """
        return _pyBasePython.setSC_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(self, x) -> std::set< signed char,std::less< signed char > >::iterator

        Parameters
        ----------
        x: std::set< signed char,std::less< signed char > >::key_type const &

        """
        return _pyBasePython.setSC_upper_bound(self, x)

    def equal_range(self, x):
        r"""
        equal_range(self, x) -> std::pair< std::set< signed char,std::less< signed char > >::iterator,std::set< signed char,std::less< signed char > >::iterator >

        Parameters
        ----------
        x: std::set< signed char,std::less< signed char > >::key_type const &

        """
        return _pyBasePython.setSC_equal_range(self, x)

    def insert(self, __x):
        r"""
        insert(self, __x) -> std::pair< std::set< signed char,std::less< signed char > >::iterator,bool >

        Parameters
        ----------
        __x: std::set< signed char,std::less< signed char > >::value_type const &

        """
        return _pyBasePython.setSC_insert(self, __x)
    __swig_destroy__ = _pyBasePython.delete_setSC

# Register setSC in _pyBasePython:
_pyBasePython.setSC_swigregister(setSC)
class setSS(collections.abc.MutableSet if _swig_python_version_info >= (3, 3) else collections.MutableSet):
    r"""Proxy of C++ std::set< short,std::less< short > > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.setSS_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.setSS___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.setSS___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::set< short,std::less< short > >::size_type"""
        return _pyBasePython.setSS___len__(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::set< short,std::less< short > >::value_type

        """
        return _pyBasePython.setSS_append(self, x)

    def __contains__(self, x):
        r"""
        __contains__(self, x) -> bool

        Parameters
        ----------
        x: std::set< short,std::less< short > >::value_type

        """
        return _pyBasePython.setSS___contains__(self, x)

    def __getitem__(self, i):
        r"""
        __getitem__(self, i) -> std::set< short,std::less< short > >::value_type

        Parameters
        ----------
        i: std::set< short,std::less< short > >::difference_type

        """
        return _pyBasePython.setSS___getitem__(self, i)

    def add(self, x):
        r"""
        add(self, x)

        Parameters
        ----------
        x: std::set< short,std::less< short > >::value_type

        """
        return _pyBasePython.setSS_add(self, x)

    def discard(self, x):
        r"""
        discard(self, x)

        Parameters
        ----------
        x: std::set< short,std::less< short > >::value_type

        """
        return _pyBasePython.setSS_discard(self, x)

    def __init__(self, *args):
        r"""
        __init__(self, other) -> setSS

        Parameters
        ----------
        other: std::less< short > const &

        __init__(self) -> setSS
        __init__(self, other) -> setSS

        Parameters
        ----------
        other: std::set< short,std::less< short > > const &

        """
        _pyBasePython.setSS_swiginit(self, _pyBasePython.new_setSS(*args))

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.setSS_empty(self)

    def size(self):
        r"""size(self) -> std::set< short,std::less< short > >::size_type"""
        return _pyBasePython.setSS_size(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.setSS_clear(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::set< short,std::less< short > > &

        """
        return _pyBasePython.setSS_swap(self, v)

    def count(self, x):
        r"""
        count(self, x) -> std::set< short,std::less< short > >::size_type

        Parameters
        ----------
        x: std::set< short,std::less< short > >::key_type const &

        """
        return _pyBasePython.setSS_count(self, x)

    def begin(self):
        r"""begin(self) -> std::set< short,std::less< short > >::iterator"""
        return _pyBasePython.setSS_begin(self)

    def end(self):
        r"""end(self) -> std::set< short,std::less< short > >::iterator"""
        return _pyBasePython.setSS_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::set< short,std::less< short > >::reverse_iterator"""
        return _pyBasePython.setSS_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::set< short,std::less< short > >::reverse_iterator"""
        return _pyBasePython.setSS_rend(self)

    def erase(self, *args):
        r"""
        erase(self, x) -> std::set< short,std::less< short > >::size_type

        Parameters
        ----------
        x: std::set< short,std::less< short > >::key_type const &

        erase(self, pos)

        Parameters
        ----------
        pos: std::set< short,std::less< short > >::iterator

        erase(self, first, last)

        Parameters
        ----------
        first: std::set< short,std::less< short > >::iterator
        last: std::set< short,std::less< short > >::iterator

        """
        return _pyBasePython.setSS_erase(self, *args)

    def find(self, x):
        r"""
        find(self, x) -> std::set< short,std::less< short > >::iterator

        Parameters
        ----------
        x: std::set< short,std::less< short > >::key_type const &

        """
        return _pyBasePython.setSS_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(self, x) -> std::set< short,std::less< short > >::iterator

        Parameters
        ----------
        x: std::set< short,std::less< short > >::key_type const &

        """
        return _pyBasePython.setSS_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(self, x) -> std::set< short,std::less< short > >::iterator

        Parameters
        ----------
        x: std::set< short,std::less< short > >::key_type const &

        """
        return _pyBasePython.setSS_upper_bound(self, x)

    def equal_range(self, x):
        r"""
        equal_range(self, x) -> std::pair< std::set< short,std::less< short > >::iterator,std::set< short,std::less< short > >::iterator >

        Parameters
        ----------
        x: std::set< short,std::less< short > >::key_type const &

        """
        return _pyBasePython.setSS_equal_range(self, x)

    def insert(self, __x):
        r"""
        insert(self, __x) -> std::pair< std::set< short,std::less< short > >::iterator,bool >

        Parameters
        ----------
        __x: std::set< short,std::less< short > >::value_type const &

        """
        return _pyBasePython.setSS_insert(self, __x)
    __swig_destroy__ = _pyBasePython.delete_setSS

# Register setSS in _pyBasePython:
_pyBasePython.setSS_swigregister(setSS)
class setSL(collections.abc.MutableSet if _swig_python_version_info >= (3, 3) else collections.MutableSet):
    r"""Proxy of C++ std::set< long,std::less< long > > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.setSL_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.setSL___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.setSL___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::set< long,std::less< long > >::size_type"""
        return _pyBasePython.setSL___len__(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::set< long,std::less< long > >::value_type

        """
        return _pyBasePython.setSL_append(self, x)

    def __contains__(self, x):
        r"""
        __contains__(self, x) -> bool

        Parameters
        ----------
        x: std::set< long,std::less< long > >::value_type

        """
        return _pyBasePython.setSL___contains__(self, x)

    def __getitem__(self, i):
        r"""
        __getitem__(self, i) -> std::set< long,std::less< long > >::value_type

        Parameters
        ----------
        i: std::set< long,std::less< long > >::difference_type

        """
        return _pyBasePython.setSL___getitem__(self, i)

    def add(self, x):
        r"""
        add(self, x)

        Parameters
        ----------
        x: std::set< long,std::less< long > >::value_type

        """
        return _pyBasePython.setSL_add(self, x)

    def discard(self, x):
        r"""
        discard(self, x)

        Parameters
        ----------
        x: std::set< long,std::less< long > >::value_type

        """
        return _pyBasePython.setSL_discard(self, x)

    def __init__(self, *args):
        r"""
        __init__(self, other) -> setSL

        Parameters
        ----------
        other: std::less< long > const &

        __init__(self) -> setSL
        __init__(self, other) -> setSL

        Parameters
        ----------
        other: std::set< long,std::less< long > > const &

        """
        _pyBasePython.setSL_swiginit(self, _pyBasePython.new_setSL(*args))

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.setSL_empty(self)

    def size(self):
        r"""size(self) -> std::set< long,std::less< long > >::size_type"""
        return _pyBasePython.setSL_size(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.setSL_clear(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::set< long,std::less< long > > &

        """
        return _pyBasePython.setSL_swap(self, v)

    def count(self, x):
        r"""
        count(self, x) -> std::set< long,std::less< long > >::size_type

        Parameters
        ----------
        x: std::set< long,std::less< long > >::key_type const &

        """
        return _pyBasePython.setSL_count(self, x)

    def begin(self):
        r"""begin(self) -> std::set< long,std::less< long > >::iterator"""
        return _pyBasePython.setSL_begin(self)

    def end(self):
        r"""end(self) -> std::set< long,std::less< long > >::iterator"""
        return _pyBasePython.setSL_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::set< long,std::less< long > >::reverse_iterator"""
        return _pyBasePython.setSL_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::set< long,std::less< long > >::reverse_iterator"""
        return _pyBasePython.setSL_rend(self)

    def erase(self, *args):
        r"""
        erase(self, x) -> std::set< long,std::less< long > >::size_type

        Parameters
        ----------
        x: std::set< long,std::less< long > >::key_type const &

        erase(self, pos)

        Parameters
        ----------
        pos: std::set< long,std::less< long > >::iterator

        erase(self, first, last)

        Parameters
        ----------
        first: std::set< long,std::less< long > >::iterator
        last: std::set< long,std::less< long > >::iterator

        """
        return _pyBasePython.setSL_erase(self, *args)

    def find(self, x):
        r"""
        find(self, x) -> std::set< long,std::less< long > >::iterator

        Parameters
        ----------
        x: std::set< long,std::less< long > >::key_type const &

        """
        return _pyBasePython.setSL_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(self, x) -> std::set< long,std::less< long > >::iterator

        Parameters
        ----------
        x: std::set< long,std::less< long > >::key_type const &

        """
        return _pyBasePython.setSL_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(self, x) -> std::set< long,std::less< long > >::iterator

        Parameters
        ----------
        x: std::set< long,std::less< long > >::key_type const &

        """
        return _pyBasePython.setSL_upper_bound(self, x)

    def equal_range(self, x):
        r"""
        equal_range(self, x) -> std::pair< std::set< long,std::less< long > >::iterator,std::set< long,std::less< long > >::iterator >

        Parameters
        ----------
        x: std::set< long,std::less< long > >::key_type const &

        """
        return _pyBasePython.setSL_equal_range(self, x)

    def insert(self, __x):
        r"""
        insert(self, __x) -> std::pair< std::set< long,std::less< long > >::iterator,bool >

        Parameters
        ----------
        __x: std::set< long,std::less< long > >::value_type const &

        """
        return _pyBasePython.setSL_insert(self, __x)
    __swig_destroy__ = _pyBasePython.delete_setSL

# Register setSL in _pyBasePython:
_pyBasePython.setSL_swigregister(setSL)
class setSLL(collections.abc.MutableSet if _swig_python_version_info >= (3, 3) else collections.MutableSet):
    r"""Proxy of C++ std::set< long long,std::less< long long > > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.setSLL_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.setSLL___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.setSLL___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::set< long long,std::less< long long > >::size_type"""
        return _pyBasePython.setSLL___len__(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::set< long long,std::less< long long > >::value_type

        """
        return _pyBasePython.setSLL_append(self, x)

    def __contains__(self, x):
        r"""
        __contains__(self, x) -> bool

        Parameters
        ----------
        x: std::set< long long,std::less< long long > >::value_type

        """
        return _pyBasePython.setSLL___contains__(self, x)

    def __getitem__(self, i):
        r"""
        __getitem__(self, i) -> std::set< long long,std::less< long long > >::value_type

        Parameters
        ----------
        i: std::set< long long,std::less< long long > >::difference_type

        """
        return _pyBasePython.setSLL___getitem__(self, i)

    def add(self, x):
        r"""
        add(self, x)

        Parameters
        ----------
        x: std::set< long long,std::less< long long > >::value_type

        """
        return _pyBasePython.setSLL_add(self, x)

    def discard(self, x):
        r"""
        discard(self, x)

        Parameters
        ----------
        x: std::set< long long,std::less< long long > >::value_type

        """
        return _pyBasePython.setSLL_discard(self, x)

    def __init__(self, *args):
        r"""
        __init__(self, other) -> setSLL

        Parameters
        ----------
        other: std::less< long long > const &

        __init__(self) -> setSLL
        __init__(self, other) -> setSLL

        Parameters
        ----------
        other: std::set< long long,std::less< long long > > const &

        """
        _pyBasePython.setSLL_swiginit(self, _pyBasePython.new_setSLL(*args))

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.setSLL_empty(self)

    def size(self):
        r"""size(self) -> std::set< long long,std::less< long long > >::size_type"""
        return _pyBasePython.setSLL_size(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.setSLL_clear(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::set< long long,std::less< long long > > &

        """
        return _pyBasePython.setSLL_swap(self, v)

    def count(self, x):
        r"""
        count(self, x) -> std::set< long long,std::less< long long > >::size_type

        Parameters
        ----------
        x: std::set< long long,std::less< long long > >::key_type const &

        """
        return _pyBasePython.setSLL_count(self, x)

    def begin(self):
        r"""begin(self) -> std::set< long long,std::less< long long > >::iterator"""
        return _pyBasePython.setSLL_begin(self)

    def end(self):
        r"""end(self) -> std::set< long long,std::less< long long > >::iterator"""
        return _pyBasePython.setSLL_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::set< long long,std::less< long long > >::reverse_iterator"""
        return _pyBasePython.setSLL_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::set< long long,std::less< long long > >::reverse_iterator"""
        return _pyBasePython.setSLL_rend(self)

    def erase(self, *args):
        r"""
        erase(self, x) -> std::set< long long,std::less< long long > >::size_type

        Parameters
        ----------
        x: std::set< long long,std::less< long long > >::key_type const &

        erase(self, pos)

        Parameters
        ----------
        pos: std::set< long long,std::less< long long > >::iterator

        erase(self, first, last)

        Parameters
        ----------
        first: std::set< long long,std::less< long long > >::iterator
        last: std::set< long long,std::less< long long > >::iterator

        """
        return _pyBasePython.setSLL_erase(self, *args)

    def find(self, x):
        r"""
        find(self, x) -> std::set< long long,std::less< long long > >::iterator

        Parameters
        ----------
        x: std::set< long long,std::less< long long > >::key_type const &

        """
        return _pyBasePython.setSLL_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(self, x) -> std::set< long long,std::less< long long > >::iterator

        Parameters
        ----------
        x: std::set< long long,std::less< long long > >::key_type const &

        """
        return _pyBasePython.setSLL_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(self, x) -> std::set< long long,std::less< long long > >::iterator

        Parameters
        ----------
        x: std::set< long long,std::less< long long > >::key_type const &

        """
        return _pyBasePython.setSLL_upper_bound(self, x)

    def equal_range(self, x):
        r"""
        equal_range(self, x) -> std::pair< std::set< long long,std::less< long long > >::iterator,std::set< long long,std::less< long long > >::iterator >

        Parameters
        ----------
        x: std::set< long long,std::less< long long > >::key_type const &

        """
        return _pyBasePython.setSLL_equal_range(self, x)

    def insert(self, __x):
        r"""
        insert(self, __x) -> std::pair< std::set< long long,std::less< long long > >::iterator,bool >

        Parameters
        ----------
        __x: std::set< long long,std::less< long long > >::value_type const &

        """
        return _pyBasePython.setSLL_insert(self, __x)
    __swig_destroy__ = _pyBasePython.delete_setSLL

# Register setSLL in _pyBasePython:
_pyBasePython.setSLL_swigregister(setSLL)
class setF(collections.abc.MutableSet if _swig_python_version_info >= (3, 3) else collections.MutableSet):
    r"""Proxy of C++ std::set< float,std::less< float > > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.setF_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.setF___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.setF___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::set< float,std::less< float > >::size_type"""
        return _pyBasePython.setF___len__(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::set< float,std::less< float > >::value_type

        """
        return _pyBasePython.setF_append(self, x)

    def __contains__(self, x):
        r"""
        __contains__(self, x) -> bool

        Parameters
        ----------
        x: std::set< float,std::less< float > >::value_type

        """
        return _pyBasePython.setF___contains__(self, x)

    def __getitem__(self, i):
        r"""
        __getitem__(self, i) -> std::set< float,std::less< float > >::value_type

        Parameters
        ----------
        i: std::set< float,std::less< float > >::difference_type

        """
        return _pyBasePython.setF___getitem__(self, i)

    def add(self, x):
        r"""
        add(self, x)

        Parameters
        ----------
        x: std::set< float,std::less< float > >::value_type

        """
        return _pyBasePython.setF_add(self, x)

    def discard(self, x):
        r"""
        discard(self, x)

        Parameters
        ----------
        x: std::set< float,std::less< float > >::value_type

        """
        return _pyBasePython.setF_discard(self, x)

    def __init__(self, *args):
        r"""
        __init__(self, other) -> setF

        Parameters
        ----------
        other: std::less< float > const &

        __init__(self) -> setF
        __init__(self, other) -> setF

        Parameters
        ----------
        other: std::set< float,std::less< float > > const &

        """
        _pyBasePython.setF_swiginit(self, _pyBasePython.new_setF(*args))

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.setF_empty(self)

    def size(self):
        r"""size(self) -> std::set< float,std::less< float > >::size_type"""
        return _pyBasePython.setF_size(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.setF_clear(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::set< float,std::less< float > > &

        """
        return _pyBasePython.setF_swap(self, v)

    def count(self, x):
        r"""
        count(self, x) -> std::set< float,std::less< float > >::size_type

        Parameters
        ----------
        x: std::set< float,std::less< float > >::key_type const &

        """
        return _pyBasePython.setF_count(self, x)

    def begin(self):
        r"""begin(self) -> std::set< float,std::less< float > >::iterator"""
        return _pyBasePython.setF_begin(self)

    def end(self):
        r"""end(self) -> std::set< float,std::less< float > >::iterator"""
        return _pyBasePython.setF_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::set< float,std::less< float > >::reverse_iterator"""
        return _pyBasePython.setF_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::set< float,std::less< float > >::reverse_iterator"""
        return _pyBasePython.setF_rend(self)

    def erase(self, *args):
        r"""
        erase(self, x) -> std::set< float,std::less< float > >::size_type

        Parameters
        ----------
        x: std::set< float,std::less< float > >::key_type const &

        erase(self, pos)

        Parameters
        ----------
        pos: std::set< float,std::less< float > >::iterator

        erase(self, first, last)

        Parameters
        ----------
        first: std::set< float,std::less< float > >::iterator
        last: std::set< float,std::less< float > >::iterator

        """
        return _pyBasePython.setF_erase(self, *args)

    def find(self, x):
        r"""
        find(self, x) -> std::set< float,std::less< float > >::iterator

        Parameters
        ----------
        x: std::set< float,std::less< float > >::key_type const &

        """
        return _pyBasePython.setF_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(self, x) -> std::set< float,std::less< float > >::iterator

        Parameters
        ----------
        x: std::set< float,std::less< float > >::key_type const &

        """
        return _pyBasePython.setF_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(self, x) -> std::set< float,std::less< float > >::iterator

        Parameters
        ----------
        x: std::set< float,std::less< float > >::key_type const &

        """
        return _pyBasePython.setF_upper_bound(self, x)

    def equal_range(self, x):
        r"""
        equal_range(self, x) -> std::pair< std::set< float,std::less< float > >::iterator,std::set< float,std::less< float > >::iterator >

        Parameters
        ----------
        x: std::set< float,std::less< float > >::key_type const &

        """
        return _pyBasePython.setF_equal_range(self, x)

    def insert(self, __x):
        r"""
        insert(self, __x) -> std::pair< std::set< float,std::less< float > >::iterator,bool >

        Parameters
        ----------
        __x: std::set< float,std::less< float > >::value_type const &

        """
        return _pyBasePython.setF_insert(self, __x)
    __swig_destroy__ = _pyBasePython.delete_setF

# Register setF in _pyBasePython:
_pyBasePython.setF_swigregister(setF)
class setD(collections.abc.MutableSet if _swig_python_version_info >= (3, 3) else collections.MutableSet):
    r"""Proxy of C++ std::set< double,std::less< double > > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.setD_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.setD___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.setD___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::set< double,std::less< double > >::size_type"""
        return _pyBasePython.setD___len__(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::set< double,std::less< double > >::value_type

        """
        return _pyBasePython.setD_append(self, x)

    def __contains__(self, x):
        r"""
        __contains__(self, x) -> bool

        Parameters
        ----------
        x: std::set< double,std::less< double > >::value_type

        """
        return _pyBasePython.setD___contains__(self, x)

    def __getitem__(self, i):
        r"""
        __getitem__(self, i) -> std::set< double,std::less< double > >::value_type

        Parameters
        ----------
        i: std::set< double,std::less< double > >::difference_type

        """
        return _pyBasePython.setD___getitem__(self, i)

    def add(self, x):
        r"""
        add(self, x)

        Parameters
        ----------
        x: std::set< double,std::less< double > >::value_type

        """
        return _pyBasePython.setD_add(self, x)

    def discard(self, x):
        r"""
        discard(self, x)

        Parameters
        ----------
        x: std::set< double,std::less< double > >::value_type

        """
        return _pyBasePython.setD_discard(self, x)

    def __init__(self, *args):
        r"""
        __init__(self, other) -> setD

        Parameters
        ----------
        other: std::less< double > const &

        __init__(self) -> setD
        __init__(self, other) -> setD

        Parameters
        ----------
        other: std::set< double,std::less< double > > const &

        """
        _pyBasePython.setD_swiginit(self, _pyBasePython.new_setD(*args))

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.setD_empty(self)

    def size(self):
        r"""size(self) -> std::set< double,std::less< double > >::size_type"""
        return _pyBasePython.setD_size(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.setD_clear(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::set< double,std::less< double > > &

        """
        return _pyBasePython.setD_swap(self, v)

    def count(self, x):
        r"""
        count(self, x) -> std::set< double,std::less< double > >::size_type

        Parameters
        ----------
        x: std::set< double,std::less< double > >::key_type const &

        """
        return _pyBasePython.setD_count(self, x)

    def begin(self):
        r"""begin(self) -> std::set< double,std::less< double > >::iterator"""
        return _pyBasePython.setD_begin(self)

    def end(self):
        r"""end(self) -> std::set< double,std::less< double > >::iterator"""
        return _pyBasePython.setD_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::set< double,std::less< double > >::reverse_iterator"""
        return _pyBasePython.setD_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::set< double,std::less< double > >::reverse_iterator"""
        return _pyBasePython.setD_rend(self)

    def erase(self, *args):
        r"""
        erase(self, x) -> std::set< double,std::less< double > >::size_type

        Parameters
        ----------
        x: std::set< double,std::less< double > >::key_type const &

        erase(self, pos)

        Parameters
        ----------
        pos: std::set< double,std::less< double > >::iterator

        erase(self, first, last)

        Parameters
        ----------
        first: std::set< double,std::less< double > >::iterator
        last: std::set< double,std::less< double > >::iterator

        """
        return _pyBasePython.setD_erase(self, *args)

    def find(self, x):
        r"""
        find(self, x) -> std::set< double,std::less< double > >::iterator

        Parameters
        ----------
        x: std::set< double,std::less< double > >::key_type const &

        """
        return _pyBasePython.setD_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(self, x) -> std::set< double,std::less< double > >::iterator

        Parameters
        ----------
        x: std::set< double,std::less< double > >::key_type const &

        """
        return _pyBasePython.setD_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(self, x) -> std::set< double,std::less< double > >::iterator

        Parameters
        ----------
        x: std::set< double,std::less< double > >::key_type const &

        """
        return _pyBasePython.setD_upper_bound(self, x)

    def equal_range(self, x):
        r"""
        equal_range(self, x) -> std::pair< std::set< double,std::less< double > >::iterator,std::set< double,std::less< double > >::iterator >

        Parameters
        ----------
        x: std::set< double,std::less< double > >::key_type const &

        """
        return _pyBasePython.setD_equal_range(self, x)

    def insert(self, __x):
        r"""
        insert(self, __x) -> std::pair< std::set< double,std::less< double > >::iterator,bool >

        Parameters
        ----------
        __x: std::set< double,std::less< double > >::value_type const &

        """
        return _pyBasePython.setD_insert(self, __x)
    __swig_destroy__ = _pyBasePython.delete_setD

# Register setD in _pyBasePython:
_pyBasePython.setD_swigregister(setD)
class vectorsetUL(collections.abc.MutableSequence if _swig_python_version_info >= (3, 3) else collections.MutableSequence):
    r"""Proxy of C++ std::vector< std::set< unsigned long,std::less< unsigned long > > > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.vectorsetUL_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.vectorsetUL___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.vectorsetUL___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::vector< std::set< unsigned long,std::less< unsigned long > > >::size_type"""
        return _pyBasePython.vectorsetUL___len__(self)

    def __getslice__(self, i, j):
        r"""
        __getslice__(self, i, j) -> vectorsetUL

        Parameters
        ----------
        i: std::vector< std::set< unsigned long,std::less< unsigned long > > >::difference_type
        j: std::vector< std::set< unsigned long,std::less< unsigned long > > >::difference_type

        """
        return _pyBasePython.vectorsetUL___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::set< unsigned long,std::less< unsigned long > > >::difference_type
        j: std::vector< std::set< unsigned long,std::less< unsigned long > > >::difference_type

        __setslice__(self, i, j, v)

        Parameters
        ----------
        i: std::vector< std::set< unsigned long,std::less< unsigned long > > >::difference_type
        j: std::vector< std::set< unsigned long,std::less< unsigned long > > >::difference_type
        v: std::vector< std::set< unsigned long,std::less< unsigned long >,std::allocator< unsigned long > >,std::allocator< std::set< unsigned long,std::less< unsigned long >,std::allocator< unsigned long > > > > const &

        """
        return _pyBasePython.vectorsetUL___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""
        __delslice__(self, i, j)

        Parameters
        ----------
        i: std::vector< std::set< unsigned long,std::less< unsigned long > > >::difference_type
        j: std::vector< std::set< unsigned long,std::less< unsigned long > > >::difference_type

        """
        return _pyBasePython.vectorsetUL___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(self, i)

        Parameters
        ----------
        i: std::vector< std::set< unsigned long,std::less< unsigned long > > >::difference_type

        __delitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        """
        return _pyBasePython.vectorsetUL___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(self, slice) -> vectorsetUL

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __getitem__(self, i) -> setUL

        Parameters
        ----------
        i: std::vector< std::set< unsigned long,std::less< unsigned long > > >::difference_type

        """
        return _pyBasePython.vectorsetUL___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, slice, v)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< std::set< unsigned long,std::less< unsigned long >,std::allocator< unsigned long > >,std::allocator< std::set< unsigned long,std::less< unsigned long >,std::allocator< unsigned long > > > > const &

        __setitem__(self, slice)

        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *

        __setitem__(self, i, x)

        Parameters
        ----------
        i: std::vector< std::set< unsigned long,std::less< unsigned long > > >::difference_type
        x: std::vector< std::set< unsigned long,std::less< unsigned long > > >::value_type const &

        """
        return _pyBasePython.vectorsetUL___setitem__(self, *args)

    def pop(self):
        r"""pop(self) -> setUL"""
        return _pyBasePython.vectorsetUL_pop(self)

    def append(self, x):
        r"""
        append(self, x)

        Parameters
        ----------
        x: std::vector< std::set< unsigned long,std::less< unsigned long > > >::value_type const &

        """
        return _pyBasePython.vectorsetUL_append(self, x)

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.vectorsetUL_empty(self)

    def size(self):
        r"""size(self) -> std::vector< std::set< unsigned long,std::less< unsigned long > > >::size_type"""
        return _pyBasePython.vectorsetUL_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::vector< std::set< unsigned long,std::less< unsigned long >,std::allocator< unsigned long > > > &

        """
        return _pyBasePython.vectorsetUL_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::vector< std::set< unsigned long,std::less< unsigned long > > >::iterator"""
        return _pyBasePython.vectorsetUL_begin(self)

    def end(self):
        r"""end(self) -> std::vector< std::set< unsigned long,std::less< unsigned long > > >::iterator"""
        return _pyBasePython.vectorsetUL_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::vector< std::set< unsigned long,std::less< unsigned long > > >::reverse_iterator"""
        return _pyBasePython.vectorsetUL_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::vector< std::set< unsigned long,std::less< unsigned long > > >::reverse_iterator"""
        return _pyBasePython.vectorsetUL_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.vectorsetUL_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::vector< std::set< unsigned long,std::less< unsigned long > > >::allocator_type"""
        return _pyBasePython.vectorsetUL_get_allocator(self)

    def pop_back(self):
        r"""pop_back(self)"""
        return _pyBasePython.vectorsetUL_pop_back(self)

    def erase(self, *args):
        r"""
        erase(self, pos) -> std::vector< std::set< unsigned long,std::less< unsigned long > > >::iterator

        Parameters
        ----------
        pos: std::vector< std::set< unsigned long,std::less< unsigned long > > >::iterator

        erase(self, first, last) -> std::vector< std::set< unsigned long,std::less< unsigned long > > >::iterator

        Parameters
        ----------
        first: std::vector< std::set< unsigned long,std::less< unsigned long > > >::iterator
        last: std::vector< std::set< unsigned long,std::less< unsigned long > > >::iterator

        """
        return _pyBasePython.vectorsetUL_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(self) -> vectorsetUL
        __init__(self, other) -> vectorsetUL

        Parameters
        ----------
        other: std::vector< std::set< unsigned long,std::less< unsigned long >,std::allocator< unsigned long > > > const &

        __init__(self, size) -> vectorsetUL

        Parameters
        ----------
        size: std::vector< std::set< unsigned long,std::less< unsigned long > > >::size_type

        __init__(self, size, value) -> vectorsetUL

        Parameters
        ----------
        size: std::vector< std::set< unsigned long,std::less< unsigned long > > >::size_type
        value: std::vector< std::set< unsigned long,std::less< unsigned long > > >::value_type const &

        """
        _pyBasePython.vectorsetUL_swiginit(self, _pyBasePython.new_vectorsetUL(*args))

    def push_back(self, x):
        r"""
        push_back(self, x)

        Parameters
        ----------
        x: std::vector< std::set< unsigned long,std::less< unsigned long > > >::value_type const &

        """
        return _pyBasePython.vectorsetUL_push_back(self, x)

    def front(self):
        r"""front(self) -> setUL"""
        return _pyBasePython.vectorsetUL_front(self)

    def back(self):
        r"""back(self) -> setUL"""
        return _pyBasePython.vectorsetUL_back(self)

    def assign(self, n, x):
        r"""
        assign(self, n, x)

        Parameters
        ----------
        n: std::vector< std::set< unsigned long,std::less< unsigned long > > >::size_type
        x: std::vector< std::set< unsigned long,std::less< unsigned long > > >::value_type const &

        """
        return _pyBasePython.vectorsetUL_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(self, new_size)

        Parameters
        ----------
        new_size: std::vector< std::set< unsigned long,std::less< unsigned long > > >::size_type

        resize(self, new_size, x)

        Parameters
        ----------
        new_size: std::vector< std::set< unsigned long,std::less< unsigned long > > >::size_type
        x: std::vector< std::set< unsigned long,std::less< unsigned long > > >::value_type const &

        """
        return _pyBasePython.vectorsetUL_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(self, pos, x) -> std::vector< std::set< unsigned long,std::less< unsigned long > > >::iterator

        Parameters
        ----------
        pos: std::vector< std::set< unsigned long,std::less< unsigned long > > >::iterator
        x: std::vector< std::set< unsigned long,std::less< unsigned long > > >::value_type const &

        insert(self, pos, n, x)

        Parameters
        ----------
        pos: std::vector< std::set< unsigned long,std::less< unsigned long > > >::iterator
        n: std::vector< std::set< unsigned long,std::less< unsigned long > > >::size_type
        x: std::vector< std::set< unsigned long,std::less< unsigned long > > >::value_type const &

        """
        return _pyBasePython.vectorsetUL_insert(self, *args)

    def reserve(self, n):
        r"""
        reserve(self, n)

        Parameters
        ----------
        n: std::vector< std::set< unsigned long,std::less< unsigned long > > >::size_type

        """
        return _pyBasePython.vectorsetUL_reserve(self, n)

    def capacity(self):
        r"""capacity(self) -> std::vector< std::set< unsigned long,std::less< unsigned long > > >::size_type"""
        return _pyBasePython.vectorsetUL_capacity(self)
    __swig_destroy__ = _pyBasePython.delete_vectorsetUL

# Register vectorsetUL in _pyBasePython:
_pyBasePython.vectorsetUL_swigregister(vectorsetUL)
class mapsetUL(collections.abc.MutableMapping if _swig_python_version_info >= (3, 3) else collections.MutableMapping):
    r"""Proxy of C++ std::map< unsigned long,std::set< unsigned long,std::less< unsigned long > > > class."""

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

    def iterator(self):
        r"""iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapsetUL_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(self) -> bool"""
        return _pyBasePython.mapsetUL___nonzero__(self)

    def __bool__(self):
        r"""__bool__(self) -> bool"""
        return _pyBasePython.mapsetUL___bool__(self)

    def __len__(self):
        r"""__len__(self) -> std::map< unsigned long,std::set< unsigned long,std::less< unsigned long > > >::size_type"""
        return _pyBasePython.mapsetUL___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):
        r"""
        __getitem__(self, key) -> setUL

        Parameters
        ----------
        key: std::map< unsigned long,std::set< unsigned long,std::less< unsigned long > > >::key_type const &

        """
        return _pyBasePython.mapsetUL___getitem__(self, key)

    def __delitem__(self, key):
        r"""
        __delitem__(self, key)

        Parameters
        ----------
        key: std::map< unsigned long,std::set< unsigned long,std::less< unsigned long > > >::key_type const &

        """
        return _pyBasePython.mapsetUL___delitem__(self, key)

    def has_key(self, key):
        r"""
        has_key(self, key) -> bool

        Parameters
        ----------
        key: std::map< unsigned long,std::set< unsigned long,std::less< unsigned long > > >::key_type const &

        """
        return _pyBasePython.mapsetUL_has_key(self, key)

    def keys(self):
        r"""keys(self) -> PyObject *"""
        return _pyBasePython.mapsetUL_keys(self)

    def values(self):
        r"""values(self) -> PyObject *"""
        return _pyBasePython.mapsetUL_values(self)

    def items(self):
        r"""items(self) -> PyObject *"""
        return _pyBasePython.mapsetUL_items(self)

    def __contains__(self, key):
        r"""
        __contains__(self, key) -> bool

        Parameters
        ----------
        key: std::map< unsigned long,std::set< unsigned long,std::less< unsigned long > > >::key_type const &

        """
        return _pyBasePython.mapsetUL___contains__(self, key)

    def key_iterator(self):
        r"""key_iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapsetUL_key_iterator(self)

    def value_iterator(self):
        r"""value_iterator(self) -> SwigPyIterator"""
        return _pyBasePython.mapsetUL_value_iterator(self)

    def __setitem__(self, *args):
        r"""
        __setitem__(self, key)

        Parameters
        ----------
        key: std::map< unsigned long,std::set< unsigned long,std::less< unsigned long > > >::key_type const &

        __setitem__(self, key, x)

        Parameters
        ----------
        key: std::map< unsigned long,std::set< unsigned long,std::less< unsigned long > > >::key_type const &
        x: std::map< unsigned long,std::set< unsigned long,std::less< unsigned long > > >::mapped_type const &

        """
        return _pyBasePython.mapsetUL___setitem__(self, *args)

    def asdict(self):
        r"""asdict(self) -> PyObject *"""
        return _pyBasePython.mapsetUL_asdict(self)

    def __init__(self, *args):
        r"""
        __init__(self, other) -> mapsetUL

        Parameters
        ----------
        other: std::less< unsigned long > const &

        __init__(self) -> mapsetUL
        __init__(self, other) -> mapsetUL

        Parameters
        ----------
        other: std::map< unsigned long,std::set< unsigned long,std::less< unsigned long >,std::allocator< unsigned long > > > const &

        """
        _pyBasePython.mapsetUL_swiginit(self, _pyBasePython.new_mapsetUL(*args))

    def empty(self):
        r"""empty(self) -> bool"""
        return _pyBasePython.mapsetUL_empty(self)

    def size(self):
        r"""size(self) -> std::map< unsigned long,std::set< unsigned long,std::less< unsigned long > > >::size_type"""
        return _pyBasePython.mapsetUL_size(self)

    def swap(self, v):
        r"""
        swap(self, v)

        Parameters
        ----------
        v: std::map< unsigned long,std::set< unsigned long,std::less< unsigned long >,std::allocator< unsigned long > > > &

        """
        return _pyBasePython.mapsetUL_swap(self, v)

    def begin(self):
        r"""begin(self) -> std::map< unsigned long,std::set< unsigned long,std::less< unsigned long > > >::iterator"""
        return _pyBasePython.mapsetUL_begin(self)

    def end(self):
        r"""end(self) -> std::map< unsigned long,std::set< unsigned long,std::less< unsigned long > > >::iterator"""
        return _pyBasePython.mapsetUL_end(self)

    def rbegin(self):
        r"""rbegin(self) -> std::map< unsigned long,std::set< unsigned long,std::less< unsigned long > > >::reverse_iterator"""
        return _pyBasePython.mapsetUL_rbegin(self)

    def rend(self):
        r"""rend(self) -> std::map< unsigned long,std::set< unsigned long,std::less< unsigned long > > >::reverse_iterator"""
        return _pyBasePython.mapsetUL_rend(self)

    def clear(self):
        r"""clear(self)"""
        return _pyBasePython.mapsetUL_clear(self)

    def get_allocator(self):
        r"""get_allocator(self) -> std::map< unsigned long,std::set< unsigned long,std::less< unsigned long > > >::allocator_type"""
        return _pyBasePython.mapsetUL_get_allocator(self)

    def count(self, x):
        r"""
        count(self, x) -> std::map< unsigned long,std::set< unsigned long,std::less< unsigned long > > >::size_type

        Parameters
        ----------
        x: std::map< unsigned long,std::set< unsigned long,std::less< unsigned long > > >::key_type const &

        """
        return _pyBasePython.mapsetUL_count(self, x)

    def erase(self, *args):
        r"""
        erase(self, x) -> std::map< unsigned long,std::set< unsigned long,std::less< unsigned long > > >::size_type

        Parameters
        ----------
        x: std::map< unsigned long,std::set< unsigned long,std::less< unsigned long > > >::key_type const &

        erase(self, position)

        Parameters
        ----------
        position: std::map< unsigned long,std::set< unsigned long,std::less< unsigned long > > >::iterator

        erase(self, first, last)

        Parameters
        ----------
        first: std::map< unsigned long,std::set< unsigned long,std::less< unsigned long > > >::iterator
        last: std::map< unsigned long,std::set< unsigned long,std::less< unsigned long > > >::iterator

        """
        return _pyBasePython.mapsetUL_erase(self, *args)

    def find(self, x):
        r"""
        find(self, x) -> std::map< unsigned long,std::set< unsigned long,std::less< unsigned long > > >::iterator

        Parameters
        ----------
        x: std::map< unsigned long,std::set< unsigned long,std::less< unsigned long > > >::key_type const &

        """
        return _pyBasePython.mapsetUL_find(self, x)

    def lower_bound(self, x):
        r"""
        lower_bound(self, x) -> std::map< unsigned long,std::set< unsigned long,std::less< unsigned long > > >::iterator

        Parameters
        ----------
        x: std::map< unsigned long,std::set< unsigned long,std::less< unsigned long > > >::key_type const &

        """
        return _pyBasePython.mapsetUL_lower_bound(self, x)

    def upper_bound(self, x):
        r"""
        upper_bound(self, x) -> std::map< unsigned long,std::set< unsigned long,std::less< unsigned long > > >::iterator

        Parameters
        ----------
        x: std::map< unsigned long,std::set< unsigned long,std::less< unsigned long > > >::key_type const &

        """
        return _pyBasePython.mapsetUL_upper_bound(self, x)
    __swig_destroy__ = _pyBasePython.delete_mapsetUL

# Register mapsetUL in _pyBasePython:
_pyBasePython.mapsetUL_swigregister(mapsetUL)

