# 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 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__

_swig_new_instance_method = _pyBasePython.SWIG_PyInstanceMethod_New
_swig_new_static_method = _pyBasePython.SWIG_PyStaticMethod_New

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__)


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
    value = _swig_new_instance_method(_pyBasePython.SwigPyIterator_value)
    incr = _swig_new_instance_method(_pyBasePython.SwigPyIterator_incr)
    decr = _swig_new_instance_method(_pyBasePython.SwigPyIterator_decr)
    distance = _swig_new_instance_method(_pyBasePython.SwigPyIterator_distance)
    equal = _swig_new_instance_method(_pyBasePython.SwigPyIterator_equal)
    copy = _swig_new_instance_method(_pyBasePython.SwigPyIterator_copy)
    next = _swig_new_instance_method(_pyBasePython.SwigPyIterator_next)
    __next__ = _swig_new_instance_method(_pyBasePython.SwigPyIterator___next__)
    previous = _swig_new_instance_method(_pyBasePython.SwigPyIterator_previous)
    advance = _swig_new_instance_method(_pyBasePython.SwigPyIterator_advance)
    __eq__ = _swig_new_instance_method(_pyBasePython.SwigPyIterator___eq__)
    __ne__ = _swig_new_instance_method(_pyBasePython.SwigPyIterator___ne__)
    __iadd__ = _swig_new_instance_method(_pyBasePython.SwigPyIterator___iadd__)
    __isub__ = _swig_new_instance_method(_pyBasePython.SwigPyIterator___isub__)
    __add__ = _swig_new_instance_method(_pyBasePython.SwigPyIterator___add__)
    __sub__ = _swig_new_instance_method(_pyBasePython.SwigPyIterator___sub__)
    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
    
    register_callback = _swig_new_instance_method(_pyBasePython.ios_base_register_callback)
    flags = _swig_new_instance_method(_pyBasePython.ios_base_flags)
    setf = _swig_new_instance_method(_pyBasePython.ios_base_setf)
    unsetf = _swig_new_instance_method(_pyBasePython.ios_base_unsetf)
    precision = _swig_new_instance_method(_pyBasePython.ios_base_precision)
    width = _swig_new_instance_method(_pyBasePython.ios_base_width)
    sync_with_stdio = _swig_new_static_method(_pyBasePython.ios_base_sync_with_stdio)
    imbue = _swig_new_instance_method(_pyBasePython.ios_base_imbue)
    getloc = _swig_new_instance_method(_pyBasePython.ios_base_getloc)
    xalloc = _swig_new_static_method(_pyBasePython.ios_base_xalloc)
    iword = _swig_new_instance_method(_pyBasePython.ios_base_iword)
    pword = _swig_new_instance_method(_pyBasePython.ios_base_pword)
    __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
    rdstate = _swig_new_instance_method(_pyBasePython.ios_rdstate)
    clear = _swig_new_instance_method(_pyBasePython.ios_clear)
    setstate = _swig_new_instance_method(_pyBasePython.ios_setstate)
    good = _swig_new_instance_method(_pyBasePython.ios_good)
    eof = _swig_new_instance_method(_pyBasePython.ios_eof)
    fail = _swig_new_instance_method(_pyBasePython.ios_fail)
    bad = _swig_new_instance_method(_pyBasePython.ios_bad)
    exceptions = _swig_new_instance_method(_pyBasePython.ios_exceptions)

    def __init__(self, __sb):
        r"""__init__(ios self, std::basic_streambuf< char,std::char_traits< char > > * __sb) -> ios"""
        _pyBasePython.ios_swiginit(self, _pyBasePython.new_ios(__sb))
    __swig_destroy__ = _pyBasePython.delete_ios
    tie = _swig_new_instance_method(_pyBasePython.ios_tie)
    rdbuf = _swig_new_instance_method(_pyBasePython.ios_rdbuf)
    copyfmt = _swig_new_instance_method(_pyBasePython.ios_copyfmt)
    fill = _swig_new_instance_method(_pyBasePython.ios_fill)
    imbue = _swig_new_instance_method(_pyBasePython.ios_imbue)
    narrow = _swig_new_instance_method(_pyBasePython.ios_narrow)
    widen = _swig_new_instance_method(_pyBasePython.ios_widen)

# 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__(ostream self, std::basic_streambuf< char,std::char_traits< char > > * __sb) -> ostream"""
        _pyBasePython.ostream_swiginit(self, _pyBasePython.new_ostream(__sb))
    __swig_destroy__ = _pyBasePython.delete_ostream
    __lshift__ = _swig_new_instance_method(_pyBasePython.ostream___lshift__)
    put = _swig_new_instance_method(_pyBasePython.ostream_put)
    write = _swig_new_instance_method(_pyBasePython.ostream_write)
    flush = _swig_new_instance_method(_pyBasePython.ostream_flush)
    tellp = _swig_new_instance_method(_pyBasePython.ostream_tellp)
    seekp = _swig_new_instance_method(_pyBasePython.ostream_seekp)

# 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__(istream self, std::basic_streambuf< char,std::char_traits< char > > * __sb) -> istream"""
        _pyBasePython.istream_swiginit(self, _pyBasePython.new_istream(__sb))
    __swig_destroy__ = _pyBasePython.delete_istream
    __rshift__ = _swig_new_instance_method(_pyBasePython.istream___rshift__)
    gcount = _swig_new_instance_method(_pyBasePython.istream_gcount)
    get = _swig_new_instance_method(_pyBasePython.istream_get)
    getline = _swig_new_instance_method(_pyBasePython.istream_getline)
    ignore = _swig_new_instance_method(_pyBasePython.istream_ignore)
    peek = _swig_new_instance_method(_pyBasePython.istream_peek)
    read = _swig_new_instance_method(_pyBasePython.istream_read)
    readsome = _swig_new_instance_method(_pyBasePython.istream_readsome)
    putback = _swig_new_instance_method(_pyBasePython.istream_putback)
    unget = _swig_new_instance_method(_pyBasePython.istream_unget)
    sync = _swig_new_instance_method(_pyBasePython.istream_sync)
    tellg = _swig_new_instance_method(_pyBasePython.istream_tellg)
    seekg = _swig_new_instance_method(_pyBasePython.istream_seekg)

# 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__(iostream self, std::basic_streambuf< char,std::char_traits< char > > * __sb) -> iostream"""
        _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 vectorstring(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.vectorstring_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.vectorstring___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.vectorstring___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.vectorstring___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.vectorstring___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.vectorstring___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.vectorstring___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.vectorstring___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.vectorstring___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.vectorstring___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.vectorstring_pop)
    append = _swig_new_instance_method(_pyBasePython.vectorstring_append)
    empty = _swig_new_instance_method(_pyBasePython.vectorstring_empty)
    size = _swig_new_instance_method(_pyBasePython.vectorstring_size)
    swap = _swig_new_instance_method(_pyBasePython.vectorstring_swap)
    begin = _swig_new_instance_method(_pyBasePython.vectorstring_begin)
    end = _swig_new_instance_method(_pyBasePython.vectorstring_end)
    rbegin = _swig_new_instance_method(_pyBasePython.vectorstring_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.vectorstring_rend)
    clear = _swig_new_instance_method(_pyBasePython.vectorstring_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.vectorstring_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.vectorstring_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.vectorstring_erase)

    def __init__(self, *args):
        r"""
        __init__(vectorstring self) -> vectorstring
        __init__(vectorstring self, vectorstring other) -> vectorstring
        __init__(vectorstring self, std::vector< std::string >::size_type size) -> vectorstring
        __init__(vectorstring self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> vectorstring
        """
        _pyBasePython.vectorstring_swiginit(self, _pyBasePython.new_vectorstring(*args))
    push_back = _swig_new_instance_method(_pyBasePython.vectorstring_push_back)
    front = _swig_new_instance_method(_pyBasePython.vectorstring_front)
    back = _swig_new_instance_method(_pyBasePython.vectorstring_back)
    assign = _swig_new_instance_method(_pyBasePython.vectorstring_assign)
    resize = _swig_new_instance_method(_pyBasePython.vectorstring_resize)
    insert = _swig_new_instance_method(_pyBasePython.vectorstring_insert)
    reserve = _swig_new_instance_method(_pyBasePython.vectorstring_reserve)
    capacity = _swig_new_instance_method(_pyBasePython.vectorstring_capacity)
    __swig_destroy__ = _pyBasePython.delete_vectorstring

# Register vectorstring in _pyBasePython:
_pyBasePython.vectorstring_swigregister(vectorstring)
class liststring(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.liststring_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.liststring___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.liststring___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.liststring___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.liststring___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.liststring___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.liststring___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.liststring___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.liststring___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.liststring___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.liststring_pop)
    append = _swig_new_instance_method(_pyBasePython.liststring_append)
    empty = _swig_new_instance_method(_pyBasePython.liststring_empty)
    size = _swig_new_instance_method(_pyBasePython.liststring_size)
    swap = _swig_new_instance_method(_pyBasePython.liststring_swap)
    begin = _swig_new_instance_method(_pyBasePython.liststring_begin)
    end = _swig_new_instance_method(_pyBasePython.liststring_end)
    rbegin = _swig_new_instance_method(_pyBasePython.liststring_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.liststring_rend)
    clear = _swig_new_instance_method(_pyBasePython.liststring_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.liststring_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.liststring_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.liststring_erase)

    def __init__(self, *args):
        r"""
        __init__(liststring self) -> liststring
        __init__(liststring self, liststring other) -> liststring
        __init__(liststring self, std::list< std::string >::size_type size) -> liststring
        __init__(liststring self, std::list< std::string >::size_type size, std::list< std::string >::value_type const & value) -> liststring
        """
        _pyBasePython.liststring_swiginit(self, _pyBasePython.new_liststring(*args))
    push_back = _swig_new_instance_method(_pyBasePython.liststring_push_back)
    front = _swig_new_instance_method(_pyBasePython.liststring_front)
    back = _swig_new_instance_method(_pyBasePython.liststring_back)
    assign = _swig_new_instance_method(_pyBasePython.liststring_assign)
    resize = _swig_new_instance_method(_pyBasePython.liststring_resize)
    insert = _swig_new_instance_method(_pyBasePython.liststring_insert)
    pop_front = _swig_new_instance_method(_pyBasePython.liststring_pop_front)
    push_front = _swig_new_instance_method(_pyBasePython.liststring_push_front)
    reverse = _swig_new_instance_method(_pyBasePython.liststring_reverse)
    __swig_destroy__ = _pyBasePython.delete_liststring

# Register liststring in _pyBasePython:
_pyBasePython.liststring_swigregister(liststring)
class mapULD(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.mapULD_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.mapULD___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.mapULD___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.mapULD___len__)
    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()
    __getitem__ = _swig_new_instance_method(_pyBasePython.mapULD___getitem__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.mapULD___delitem__)
    has_key = _swig_new_instance_method(_pyBasePython.mapULD_has_key)
    keys = _swig_new_instance_method(_pyBasePython.mapULD_keys)
    values = _swig_new_instance_method(_pyBasePython.mapULD_values)
    items = _swig_new_instance_method(_pyBasePython.mapULD_items)
    __contains__ = _swig_new_instance_method(_pyBasePython.mapULD___contains__)
    key_iterator = _swig_new_instance_method(_pyBasePython.mapULD_key_iterator)
    value_iterator = _swig_new_instance_method(_pyBasePython.mapULD_value_iterator)
    __setitem__ = _swig_new_instance_method(_pyBasePython.mapULD___setitem__)
    asdict = _swig_new_instance_method(_pyBasePython.mapULD_asdict)

    def __init__(self, *args):
        r"""
        __init__(mapULD self, std::less< unsigned long > const & other) -> mapULD
        __init__(mapULD self) -> mapULD
        __init__(mapULD self, mapULD other) -> mapULD
        """
        _pyBasePython.mapULD_swiginit(self, _pyBasePython.new_mapULD(*args))
    empty = _swig_new_instance_method(_pyBasePython.mapULD_empty)
    size = _swig_new_instance_method(_pyBasePython.mapULD_size)
    swap = _swig_new_instance_method(_pyBasePython.mapULD_swap)
    begin = _swig_new_instance_method(_pyBasePython.mapULD_begin)
    end = _swig_new_instance_method(_pyBasePython.mapULD_end)
    rbegin = _swig_new_instance_method(_pyBasePython.mapULD_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.mapULD_rend)
    clear = _swig_new_instance_method(_pyBasePython.mapULD_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.mapULD_get_allocator)
    count = _swig_new_instance_method(_pyBasePython.mapULD_count)
    erase = _swig_new_instance_method(_pyBasePython.mapULD_erase)
    find = _swig_new_instance_method(_pyBasePython.mapULD_find)
    lower_bound = _swig_new_instance_method(_pyBasePython.mapULD_lower_bound)
    upper_bound = _swig_new_instance_method(_pyBasePython.mapULD_upper_bound)
    __swig_destroy__ = _pyBasePython.delete_mapULD

# Register mapULD in _pyBasePython:
_pyBasePython.mapULD_swigregister(mapULD)
class mapBB(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.mapBB_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.mapBB___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.mapBB___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.mapBB___len__)
    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()
    __getitem__ = _swig_new_instance_method(_pyBasePython.mapBB___getitem__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.mapBB___delitem__)
    has_key = _swig_new_instance_method(_pyBasePython.mapBB_has_key)
    keys = _swig_new_instance_method(_pyBasePython.mapBB_keys)
    values = _swig_new_instance_method(_pyBasePython.mapBB_values)
    items = _swig_new_instance_method(_pyBasePython.mapBB_items)
    __contains__ = _swig_new_instance_method(_pyBasePython.mapBB___contains__)
    key_iterator = _swig_new_instance_method(_pyBasePython.mapBB_key_iterator)
    value_iterator = _swig_new_instance_method(_pyBasePython.mapBB_value_iterator)
    __setitem__ = _swig_new_instance_method(_pyBasePython.mapBB___setitem__)
    asdict = _swig_new_instance_method(_pyBasePython.mapBB_asdict)

    def __init__(self, *args):
        r"""
        __init__(mapBB self, std::less< bool > const & other) -> mapBB
        __init__(mapBB self) -> mapBB
        __init__(mapBB self, mapBB other) -> mapBB
        """
        _pyBasePython.mapBB_swiginit(self, _pyBasePython.new_mapBB(*args))
    empty = _swig_new_instance_method(_pyBasePython.mapBB_empty)
    size = _swig_new_instance_method(_pyBasePython.mapBB_size)
    swap = _swig_new_instance_method(_pyBasePython.mapBB_swap)
    begin = _swig_new_instance_method(_pyBasePython.mapBB_begin)
    end = _swig_new_instance_method(_pyBasePython.mapBB_end)
    rbegin = _swig_new_instance_method(_pyBasePython.mapBB_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.mapBB_rend)
    clear = _swig_new_instance_method(_pyBasePython.mapBB_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.mapBB_get_allocator)
    count = _swig_new_instance_method(_pyBasePython.mapBB_count)
    erase = _swig_new_instance_method(_pyBasePython.mapBB_erase)
    find = _swig_new_instance_method(_pyBasePython.mapBB_find)
    lower_bound = _swig_new_instance_method(_pyBasePython.mapBB_lower_bound)
    upper_bound = _swig_new_instance_method(_pyBasePython.mapBB_upper_bound)
    __swig_destroy__ = _pyBasePython.delete_mapBB

# Register mapBB in _pyBasePython:
_pyBasePython.mapBB_swigregister(mapBB)
class mapUCUC(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.mapUCUC_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.mapUCUC___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.mapUCUC___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.mapUCUC___len__)
    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()
    __getitem__ = _swig_new_instance_method(_pyBasePython.mapUCUC___getitem__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.mapUCUC___delitem__)
    has_key = _swig_new_instance_method(_pyBasePython.mapUCUC_has_key)
    keys = _swig_new_instance_method(_pyBasePython.mapUCUC_keys)
    values = _swig_new_instance_method(_pyBasePython.mapUCUC_values)
    items = _swig_new_instance_method(_pyBasePython.mapUCUC_items)
    __contains__ = _swig_new_instance_method(_pyBasePython.mapUCUC___contains__)
    key_iterator = _swig_new_instance_method(_pyBasePython.mapUCUC_key_iterator)
    value_iterator = _swig_new_instance_method(_pyBasePython.mapUCUC_value_iterator)
    __setitem__ = _swig_new_instance_method(_pyBasePython.mapUCUC___setitem__)
    asdict = _swig_new_instance_method(_pyBasePython.mapUCUC_asdict)

    def __init__(self, *args):
        r"""
        __init__(mapUCUC self, std::less< unsigned char > const & other) -> mapUCUC
        __init__(mapUCUC self) -> mapUCUC
        __init__(mapUCUC self, mapUCUC other) -> mapUCUC
        """
        _pyBasePython.mapUCUC_swiginit(self, _pyBasePython.new_mapUCUC(*args))
    empty = _swig_new_instance_method(_pyBasePython.mapUCUC_empty)
    size = _swig_new_instance_method(_pyBasePython.mapUCUC_size)
    swap = _swig_new_instance_method(_pyBasePython.mapUCUC_swap)
    begin = _swig_new_instance_method(_pyBasePython.mapUCUC_begin)
    end = _swig_new_instance_method(_pyBasePython.mapUCUC_end)
    rbegin = _swig_new_instance_method(_pyBasePython.mapUCUC_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.mapUCUC_rend)
    clear = _swig_new_instance_method(_pyBasePython.mapUCUC_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.mapUCUC_get_allocator)
    count = _swig_new_instance_method(_pyBasePython.mapUCUC_count)
    erase = _swig_new_instance_method(_pyBasePython.mapUCUC_erase)
    find = _swig_new_instance_method(_pyBasePython.mapUCUC_find)
    lower_bound = _swig_new_instance_method(_pyBasePython.mapUCUC_lower_bound)
    upper_bound = _swig_new_instance_method(_pyBasePython.mapUCUC_upper_bound)
    __swig_destroy__ = _pyBasePython.delete_mapUCUC

# Register mapUCUC in _pyBasePython:
_pyBasePython.mapUCUC_swigregister(mapUCUC)
class mapUSUS(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.mapUSUS_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.mapUSUS___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.mapUSUS___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.mapUSUS___len__)
    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()
    __getitem__ = _swig_new_instance_method(_pyBasePython.mapUSUS___getitem__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.mapUSUS___delitem__)
    has_key = _swig_new_instance_method(_pyBasePython.mapUSUS_has_key)
    keys = _swig_new_instance_method(_pyBasePython.mapUSUS_keys)
    values = _swig_new_instance_method(_pyBasePython.mapUSUS_values)
    items = _swig_new_instance_method(_pyBasePython.mapUSUS_items)
    __contains__ = _swig_new_instance_method(_pyBasePython.mapUSUS___contains__)
    key_iterator = _swig_new_instance_method(_pyBasePython.mapUSUS_key_iterator)
    value_iterator = _swig_new_instance_method(_pyBasePython.mapUSUS_value_iterator)
    __setitem__ = _swig_new_instance_method(_pyBasePython.mapUSUS___setitem__)
    asdict = _swig_new_instance_method(_pyBasePython.mapUSUS_asdict)

    def __init__(self, *args):
        r"""
        __init__(mapUSUS self, std::less< unsigned short > const & other) -> mapUSUS
        __init__(mapUSUS self) -> mapUSUS
        __init__(mapUSUS self, mapUSUS other) -> mapUSUS
        """
        _pyBasePython.mapUSUS_swiginit(self, _pyBasePython.new_mapUSUS(*args))
    empty = _swig_new_instance_method(_pyBasePython.mapUSUS_empty)
    size = _swig_new_instance_method(_pyBasePython.mapUSUS_size)
    swap = _swig_new_instance_method(_pyBasePython.mapUSUS_swap)
    begin = _swig_new_instance_method(_pyBasePython.mapUSUS_begin)
    end = _swig_new_instance_method(_pyBasePython.mapUSUS_end)
    rbegin = _swig_new_instance_method(_pyBasePython.mapUSUS_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.mapUSUS_rend)
    clear = _swig_new_instance_method(_pyBasePython.mapUSUS_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.mapUSUS_get_allocator)
    count = _swig_new_instance_method(_pyBasePython.mapUSUS_count)
    erase = _swig_new_instance_method(_pyBasePython.mapUSUS_erase)
    find = _swig_new_instance_method(_pyBasePython.mapUSUS_find)
    lower_bound = _swig_new_instance_method(_pyBasePython.mapUSUS_lower_bound)
    upper_bound = _swig_new_instance_method(_pyBasePython.mapUSUS_upper_bound)
    __swig_destroy__ = _pyBasePython.delete_mapUSUS

# Register mapUSUS in _pyBasePython:
_pyBasePython.mapUSUS_swigregister(mapUSUS)
class mapULUL(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.mapULUL_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.mapULUL___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.mapULUL___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.mapULUL___len__)
    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()
    __getitem__ = _swig_new_instance_method(_pyBasePython.mapULUL___getitem__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.mapULUL___delitem__)
    has_key = _swig_new_instance_method(_pyBasePython.mapULUL_has_key)
    keys = _swig_new_instance_method(_pyBasePython.mapULUL_keys)
    values = _swig_new_instance_method(_pyBasePython.mapULUL_values)
    items = _swig_new_instance_method(_pyBasePython.mapULUL_items)
    __contains__ = _swig_new_instance_method(_pyBasePython.mapULUL___contains__)
    key_iterator = _swig_new_instance_method(_pyBasePython.mapULUL_key_iterator)
    value_iterator = _swig_new_instance_method(_pyBasePython.mapULUL_value_iterator)
    __setitem__ = _swig_new_instance_method(_pyBasePython.mapULUL___setitem__)
    asdict = _swig_new_instance_method(_pyBasePython.mapULUL_asdict)

    def __init__(self, *args):
        r"""
        __init__(mapULUL self, std::less< unsigned long > const & other) -> mapULUL
        __init__(mapULUL self) -> mapULUL
        __init__(mapULUL self, mapULUL other) -> mapULUL
        """
        _pyBasePython.mapULUL_swiginit(self, _pyBasePython.new_mapULUL(*args))
    empty = _swig_new_instance_method(_pyBasePython.mapULUL_empty)
    size = _swig_new_instance_method(_pyBasePython.mapULUL_size)
    swap = _swig_new_instance_method(_pyBasePython.mapULUL_swap)
    begin = _swig_new_instance_method(_pyBasePython.mapULUL_begin)
    end = _swig_new_instance_method(_pyBasePython.mapULUL_end)
    rbegin = _swig_new_instance_method(_pyBasePython.mapULUL_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.mapULUL_rend)
    clear = _swig_new_instance_method(_pyBasePython.mapULUL_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.mapULUL_get_allocator)
    count = _swig_new_instance_method(_pyBasePython.mapULUL_count)
    erase = _swig_new_instance_method(_pyBasePython.mapULUL_erase)
    find = _swig_new_instance_method(_pyBasePython.mapULUL_find)
    lower_bound = _swig_new_instance_method(_pyBasePython.mapULUL_lower_bound)
    upper_bound = _swig_new_instance_method(_pyBasePython.mapULUL_upper_bound)
    __swig_destroy__ = _pyBasePython.delete_mapULUL

# Register mapULUL in _pyBasePython:
_pyBasePython.mapULUL_swigregister(mapULUL)
class mapSCSC(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.mapSCSC_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.mapSCSC___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.mapSCSC___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.mapSCSC___len__)
    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()
    __getitem__ = _swig_new_instance_method(_pyBasePython.mapSCSC___getitem__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.mapSCSC___delitem__)
    has_key = _swig_new_instance_method(_pyBasePython.mapSCSC_has_key)
    keys = _swig_new_instance_method(_pyBasePython.mapSCSC_keys)
    values = _swig_new_instance_method(_pyBasePython.mapSCSC_values)
    items = _swig_new_instance_method(_pyBasePython.mapSCSC_items)
    __contains__ = _swig_new_instance_method(_pyBasePython.mapSCSC___contains__)
    key_iterator = _swig_new_instance_method(_pyBasePython.mapSCSC_key_iterator)
    value_iterator = _swig_new_instance_method(_pyBasePython.mapSCSC_value_iterator)
    __setitem__ = _swig_new_instance_method(_pyBasePython.mapSCSC___setitem__)
    asdict = _swig_new_instance_method(_pyBasePython.mapSCSC_asdict)

    def __init__(self, *args):
        r"""
        __init__(mapSCSC self, std::less< signed char > const & other) -> mapSCSC
        __init__(mapSCSC self) -> mapSCSC
        __init__(mapSCSC self, mapSCSC other) -> mapSCSC
        """
        _pyBasePython.mapSCSC_swiginit(self, _pyBasePython.new_mapSCSC(*args))
    empty = _swig_new_instance_method(_pyBasePython.mapSCSC_empty)
    size = _swig_new_instance_method(_pyBasePython.mapSCSC_size)
    swap = _swig_new_instance_method(_pyBasePython.mapSCSC_swap)
    begin = _swig_new_instance_method(_pyBasePython.mapSCSC_begin)
    end = _swig_new_instance_method(_pyBasePython.mapSCSC_end)
    rbegin = _swig_new_instance_method(_pyBasePython.mapSCSC_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.mapSCSC_rend)
    clear = _swig_new_instance_method(_pyBasePython.mapSCSC_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.mapSCSC_get_allocator)
    count = _swig_new_instance_method(_pyBasePython.mapSCSC_count)
    erase = _swig_new_instance_method(_pyBasePython.mapSCSC_erase)
    find = _swig_new_instance_method(_pyBasePython.mapSCSC_find)
    lower_bound = _swig_new_instance_method(_pyBasePython.mapSCSC_lower_bound)
    upper_bound = _swig_new_instance_method(_pyBasePython.mapSCSC_upper_bound)
    __swig_destroy__ = _pyBasePython.delete_mapSCSC

# Register mapSCSC in _pyBasePython:
_pyBasePython.mapSCSC_swigregister(mapSCSC)
class mapSSSS(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.mapSSSS_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.mapSSSS___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.mapSSSS___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.mapSSSS___len__)
    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()
    __getitem__ = _swig_new_instance_method(_pyBasePython.mapSSSS___getitem__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.mapSSSS___delitem__)
    has_key = _swig_new_instance_method(_pyBasePython.mapSSSS_has_key)
    keys = _swig_new_instance_method(_pyBasePython.mapSSSS_keys)
    values = _swig_new_instance_method(_pyBasePython.mapSSSS_values)
    items = _swig_new_instance_method(_pyBasePython.mapSSSS_items)
    __contains__ = _swig_new_instance_method(_pyBasePython.mapSSSS___contains__)
    key_iterator = _swig_new_instance_method(_pyBasePython.mapSSSS_key_iterator)
    value_iterator = _swig_new_instance_method(_pyBasePython.mapSSSS_value_iterator)
    __setitem__ = _swig_new_instance_method(_pyBasePython.mapSSSS___setitem__)
    asdict = _swig_new_instance_method(_pyBasePython.mapSSSS_asdict)

    def __init__(self, *args):
        r"""
        __init__(mapSSSS self, std::less< short > const & other) -> mapSSSS
        __init__(mapSSSS self) -> mapSSSS
        __init__(mapSSSS self, mapSSSS other) -> mapSSSS
        """
        _pyBasePython.mapSSSS_swiginit(self, _pyBasePython.new_mapSSSS(*args))
    empty = _swig_new_instance_method(_pyBasePython.mapSSSS_empty)
    size = _swig_new_instance_method(_pyBasePython.mapSSSS_size)
    swap = _swig_new_instance_method(_pyBasePython.mapSSSS_swap)
    begin = _swig_new_instance_method(_pyBasePython.mapSSSS_begin)
    end = _swig_new_instance_method(_pyBasePython.mapSSSS_end)
    rbegin = _swig_new_instance_method(_pyBasePython.mapSSSS_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.mapSSSS_rend)
    clear = _swig_new_instance_method(_pyBasePython.mapSSSS_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.mapSSSS_get_allocator)
    count = _swig_new_instance_method(_pyBasePython.mapSSSS_count)
    erase = _swig_new_instance_method(_pyBasePython.mapSSSS_erase)
    find = _swig_new_instance_method(_pyBasePython.mapSSSS_find)
    lower_bound = _swig_new_instance_method(_pyBasePython.mapSSSS_lower_bound)
    upper_bound = _swig_new_instance_method(_pyBasePython.mapSSSS_upper_bound)
    __swig_destroy__ = _pyBasePython.delete_mapSSSS

# Register mapSSSS in _pyBasePython:
_pyBasePython.mapSSSS_swigregister(mapSSSS)
class mapSLSL(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.mapSLSL_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.mapSLSL___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.mapSLSL___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.mapSLSL___len__)
    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()
    __getitem__ = _swig_new_instance_method(_pyBasePython.mapSLSL___getitem__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.mapSLSL___delitem__)
    has_key = _swig_new_instance_method(_pyBasePython.mapSLSL_has_key)
    keys = _swig_new_instance_method(_pyBasePython.mapSLSL_keys)
    values = _swig_new_instance_method(_pyBasePython.mapSLSL_values)
    items = _swig_new_instance_method(_pyBasePython.mapSLSL_items)
    __contains__ = _swig_new_instance_method(_pyBasePython.mapSLSL___contains__)
    key_iterator = _swig_new_instance_method(_pyBasePython.mapSLSL_key_iterator)
    value_iterator = _swig_new_instance_method(_pyBasePython.mapSLSL_value_iterator)
    __setitem__ = _swig_new_instance_method(_pyBasePython.mapSLSL___setitem__)
    asdict = _swig_new_instance_method(_pyBasePython.mapSLSL_asdict)

    def __init__(self, *args):
        r"""
        __init__(mapSLSL self, std::less< long > const & other) -> mapSLSL
        __init__(mapSLSL self) -> mapSLSL
        __init__(mapSLSL self, mapSLSL other) -> mapSLSL
        """
        _pyBasePython.mapSLSL_swiginit(self, _pyBasePython.new_mapSLSL(*args))
    empty = _swig_new_instance_method(_pyBasePython.mapSLSL_empty)
    size = _swig_new_instance_method(_pyBasePython.mapSLSL_size)
    swap = _swig_new_instance_method(_pyBasePython.mapSLSL_swap)
    begin = _swig_new_instance_method(_pyBasePython.mapSLSL_begin)
    end = _swig_new_instance_method(_pyBasePython.mapSLSL_end)
    rbegin = _swig_new_instance_method(_pyBasePython.mapSLSL_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.mapSLSL_rend)
    clear = _swig_new_instance_method(_pyBasePython.mapSLSL_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.mapSLSL_get_allocator)
    count = _swig_new_instance_method(_pyBasePython.mapSLSL_count)
    erase = _swig_new_instance_method(_pyBasePython.mapSLSL_erase)
    find = _swig_new_instance_method(_pyBasePython.mapSLSL_find)
    lower_bound = _swig_new_instance_method(_pyBasePython.mapSLSL_lower_bound)
    upper_bound = _swig_new_instance_method(_pyBasePython.mapSLSL_upper_bound)
    __swig_destroy__ = _pyBasePython.delete_mapSLSL

# Register mapSLSL in _pyBasePython:
_pyBasePython.mapSLSL_swigregister(mapSLSL)
class mapFF(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.mapFF_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.mapFF___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.mapFF___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.mapFF___len__)
    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()
    __getitem__ = _swig_new_instance_method(_pyBasePython.mapFF___getitem__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.mapFF___delitem__)
    has_key = _swig_new_instance_method(_pyBasePython.mapFF_has_key)
    keys = _swig_new_instance_method(_pyBasePython.mapFF_keys)
    values = _swig_new_instance_method(_pyBasePython.mapFF_values)
    items = _swig_new_instance_method(_pyBasePython.mapFF_items)
    __contains__ = _swig_new_instance_method(_pyBasePython.mapFF___contains__)
    key_iterator = _swig_new_instance_method(_pyBasePython.mapFF_key_iterator)
    value_iterator = _swig_new_instance_method(_pyBasePython.mapFF_value_iterator)
    __setitem__ = _swig_new_instance_method(_pyBasePython.mapFF___setitem__)
    asdict = _swig_new_instance_method(_pyBasePython.mapFF_asdict)

    def __init__(self, *args):
        r"""
        __init__(mapFF self, std::less< float > const & other) -> mapFF
        __init__(mapFF self) -> mapFF
        __init__(mapFF self, mapFF other) -> mapFF
        """
        _pyBasePython.mapFF_swiginit(self, _pyBasePython.new_mapFF(*args))
    empty = _swig_new_instance_method(_pyBasePython.mapFF_empty)
    size = _swig_new_instance_method(_pyBasePython.mapFF_size)
    swap = _swig_new_instance_method(_pyBasePython.mapFF_swap)
    begin = _swig_new_instance_method(_pyBasePython.mapFF_begin)
    end = _swig_new_instance_method(_pyBasePython.mapFF_end)
    rbegin = _swig_new_instance_method(_pyBasePython.mapFF_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.mapFF_rend)
    clear = _swig_new_instance_method(_pyBasePython.mapFF_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.mapFF_get_allocator)
    count = _swig_new_instance_method(_pyBasePython.mapFF_count)
    erase = _swig_new_instance_method(_pyBasePython.mapFF_erase)
    find = _swig_new_instance_method(_pyBasePython.mapFF_find)
    lower_bound = _swig_new_instance_method(_pyBasePython.mapFF_lower_bound)
    upper_bound = _swig_new_instance_method(_pyBasePython.mapFF_upper_bound)
    __swig_destroy__ = _pyBasePython.delete_mapFF

# Register mapFF in _pyBasePython:
_pyBasePython.mapFF_swigregister(mapFF)
class mapDD(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.mapDD_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.mapDD___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.mapDD___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.mapDD___len__)
    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()
    __getitem__ = _swig_new_instance_method(_pyBasePython.mapDD___getitem__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.mapDD___delitem__)
    has_key = _swig_new_instance_method(_pyBasePython.mapDD_has_key)
    keys = _swig_new_instance_method(_pyBasePython.mapDD_keys)
    values = _swig_new_instance_method(_pyBasePython.mapDD_values)
    items = _swig_new_instance_method(_pyBasePython.mapDD_items)
    __contains__ = _swig_new_instance_method(_pyBasePython.mapDD___contains__)
    key_iterator = _swig_new_instance_method(_pyBasePython.mapDD_key_iterator)
    value_iterator = _swig_new_instance_method(_pyBasePython.mapDD_value_iterator)
    __setitem__ = _swig_new_instance_method(_pyBasePython.mapDD___setitem__)
    asdict = _swig_new_instance_method(_pyBasePython.mapDD_asdict)

    def __init__(self, *args):
        r"""
        __init__(mapDD self, std::less< double > const & other) -> mapDD
        __init__(mapDD self) -> mapDD
        __init__(mapDD self, mapDD other) -> mapDD
        """
        _pyBasePython.mapDD_swiginit(self, _pyBasePython.new_mapDD(*args))
    empty = _swig_new_instance_method(_pyBasePython.mapDD_empty)
    size = _swig_new_instance_method(_pyBasePython.mapDD_size)
    swap = _swig_new_instance_method(_pyBasePython.mapDD_swap)
    begin = _swig_new_instance_method(_pyBasePython.mapDD_begin)
    end = _swig_new_instance_method(_pyBasePython.mapDD_end)
    rbegin = _swig_new_instance_method(_pyBasePython.mapDD_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.mapDD_rend)
    clear = _swig_new_instance_method(_pyBasePython.mapDD_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.mapDD_get_allocator)
    count = _swig_new_instance_method(_pyBasePython.mapDD_count)
    erase = _swig_new_instance_method(_pyBasePython.mapDD_erase)
    find = _swig_new_instance_method(_pyBasePython.mapDD_find)
    lower_bound = _swig_new_instance_method(_pyBasePython.mapDD_lower_bound)
    upper_bound = _swig_new_instance_method(_pyBasePython.mapDD_upper_bound)
    __swig_destroy__ = _pyBasePython.delete_mapDD

# Register mapDD in _pyBasePython:
_pyBasePython.mapDD_swigregister(mapDD)
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
    iterator = _swig_new_instance_method(_pyBasePython.vectorB_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.vectorB___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.vectorB___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.vectorB___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.vectorB___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.vectorB___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.vectorB___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.vectorB___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.vectorB___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.vectorB___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.vectorB_pop)
    append = _swig_new_instance_method(_pyBasePython.vectorB_append)
    empty = _swig_new_instance_method(_pyBasePython.vectorB_empty)
    size = _swig_new_instance_method(_pyBasePython.vectorB_size)
    swap = _swig_new_instance_method(_pyBasePython.vectorB_swap)
    begin = _swig_new_instance_method(_pyBasePython.vectorB_begin)
    end = _swig_new_instance_method(_pyBasePython.vectorB_end)
    rbegin = _swig_new_instance_method(_pyBasePython.vectorB_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.vectorB_rend)
    clear = _swig_new_instance_method(_pyBasePython.vectorB_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.vectorB_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.vectorB_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.vectorB_erase)

    def __init__(self, *args):
        r"""
        __init__(vectorB self) -> vectorB
        __init__(vectorB self, vectorB other) -> vectorB
        __init__(vectorB self, std::vector< bool >::size_type size) -> vectorB
        __init__(vectorB self, std::vector< bool >::size_type size, std::vector< bool >::value_type value) -> vectorB
        """
        _pyBasePython.vectorB_swiginit(self, _pyBasePython.new_vectorB(*args))
    push_back = _swig_new_instance_method(_pyBasePython.vectorB_push_back)
    front = _swig_new_instance_method(_pyBasePython.vectorB_front)
    back = _swig_new_instance_method(_pyBasePython.vectorB_back)
    assign = _swig_new_instance_method(_pyBasePython.vectorB_assign)
    resize = _swig_new_instance_method(_pyBasePython.vectorB_resize)
    insert = _swig_new_instance_method(_pyBasePython.vectorB_insert)
    reserve = _swig_new_instance_method(_pyBasePython.vectorB_reserve)
    capacity = _swig_new_instance_method(_pyBasePython.vectorB_capacity)
    __swig_destroy__ = _pyBasePython.delete_vectorB

# Register vectorB in _pyBasePython:
_pyBasePython.vectorB_swigregister(vectorB)
class vectorvectorB(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.vectorvectorB_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.vectorvectorB___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.vectorvectorB___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.vectorvectorB___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.vectorvectorB___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.vectorvectorB___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.vectorvectorB___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.vectorvectorB___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.vectorvectorB___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.vectorvectorB___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.vectorvectorB_pop)
    append = _swig_new_instance_method(_pyBasePython.vectorvectorB_append)
    empty = _swig_new_instance_method(_pyBasePython.vectorvectorB_empty)
    size = _swig_new_instance_method(_pyBasePython.vectorvectorB_size)
    swap = _swig_new_instance_method(_pyBasePython.vectorvectorB_swap)
    begin = _swig_new_instance_method(_pyBasePython.vectorvectorB_begin)
    end = _swig_new_instance_method(_pyBasePython.vectorvectorB_end)
    rbegin = _swig_new_instance_method(_pyBasePython.vectorvectorB_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.vectorvectorB_rend)
    clear = _swig_new_instance_method(_pyBasePython.vectorvectorB_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.vectorvectorB_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.vectorvectorB_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.vectorvectorB_erase)

    def __init__(self, *args):
        r"""
        __init__(vectorvectorB self) -> vectorvectorB
        __init__(vectorvectorB self, vectorvectorB other) -> vectorvectorB
        __init__(vectorvectorB self, std::vector< std::vector< bool > >::size_type size) -> vectorvectorB
        __init__(vectorvectorB self, std::vector< std::vector< bool > >::size_type size, vectorB value) -> vectorvectorB
        """
        _pyBasePython.vectorvectorB_swiginit(self, _pyBasePython.new_vectorvectorB(*args))
    push_back = _swig_new_instance_method(_pyBasePython.vectorvectorB_push_back)
    front = _swig_new_instance_method(_pyBasePython.vectorvectorB_front)
    back = _swig_new_instance_method(_pyBasePython.vectorvectorB_back)
    assign = _swig_new_instance_method(_pyBasePython.vectorvectorB_assign)
    resize = _swig_new_instance_method(_pyBasePython.vectorvectorB_resize)
    insert = _swig_new_instance_method(_pyBasePython.vectorvectorB_insert)
    reserve = _swig_new_instance_method(_pyBasePython.vectorvectorB_reserve)
    capacity = _swig_new_instance_method(_pyBasePython.vectorvectorB_capacity)
    __swig_destroy__ = _pyBasePython.delete_vectorvectorB

# Register vectorvectorB in _pyBasePython:
_pyBasePython.vectorvectorB_swigregister(vectorvectorB)
class vectorUC(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.vectorUC_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.vectorUC___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.vectorUC___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.vectorUC___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.vectorUC___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.vectorUC___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.vectorUC___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.vectorUC___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.vectorUC___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.vectorUC___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.vectorUC_pop)
    append = _swig_new_instance_method(_pyBasePython.vectorUC_append)
    empty = _swig_new_instance_method(_pyBasePython.vectorUC_empty)
    size = _swig_new_instance_method(_pyBasePython.vectorUC_size)
    swap = _swig_new_instance_method(_pyBasePython.vectorUC_swap)
    begin = _swig_new_instance_method(_pyBasePython.vectorUC_begin)
    end = _swig_new_instance_method(_pyBasePython.vectorUC_end)
    rbegin = _swig_new_instance_method(_pyBasePython.vectorUC_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.vectorUC_rend)
    clear = _swig_new_instance_method(_pyBasePython.vectorUC_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.vectorUC_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.vectorUC_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.vectorUC_erase)

    def __init__(self, *args):
        r"""
        __init__(vectorUC self) -> vectorUC
        __init__(vectorUC self, vectorUC other) -> vectorUC
        __init__(vectorUC self, std::vector< unsigned char >::size_type size) -> vectorUC
        __init__(vectorUC self, std::vector< unsigned char >::size_type size, std::vector< unsigned char >::value_type const & value) -> vectorUC
        """
        _pyBasePython.vectorUC_swiginit(self, _pyBasePython.new_vectorUC(*args))
    push_back = _swig_new_instance_method(_pyBasePython.vectorUC_push_back)
    front = _swig_new_instance_method(_pyBasePython.vectorUC_front)
    back = _swig_new_instance_method(_pyBasePython.vectorUC_back)
    assign = _swig_new_instance_method(_pyBasePython.vectorUC_assign)
    resize = _swig_new_instance_method(_pyBasePython.vectorUC_resize)
    insert = _swig_new_instance_method(_pyBasePython.vectorUC_insert)
    reserve = _swig_new_instance_method(_pyBasePython.vectorUC_reserve)
    capacity = _swig_new_instance_method(_pyBasePython.vectorUC_capacity)
    __swig_destroy__ = _pyBasePython.delete_vectorUC

# Register vectorUC in _pyBasePython:
_pyBasePython.vectorUC_swigregister(vectorUC)
class vectorvectorUC(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.vectorvectorUC_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.vectorvectorUC___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.vectorvectorUC___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.vectorvectorUC___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.vectorvectorUC___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.vectorvectorUC___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.vectorvectorUC___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.vectorvectorUC___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.vectorvectorUC___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.vectorvectorUC___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.vectorvectorUC_pop)
    append = _swig_new_instance_method(_pyBasePython.vectorvectorUC_append)
    empty = _swig_new_instance_method(_pyBasePython.vectorvectorUC_empty)
    size = _swig_new_instance_method(_pyBasePython.vectorvectorUC_size)
    swap = _swig_new_instance_method(_pyBasePython.vectorvectorUC_swap)
    begin = _swig_new_instance_method(_pyBasePython.vectorvectorUC_begin)
    end = _swig_new_instance_method(_pyBasePython.vectorvectorUC_end)
    rbegin = _swig_new_instance_method(_pyBasePython.vectorvectorUC_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.vectorvectorUC_rend)
    clear = _swig_new_instance_method(_pyBasePython.vectorvectorUC_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.vectorvectorUC_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.vectorvectorUC_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.vectorvectorUC_erase)

    def __init__(self, *args):
        r"""
        __init__(vectorvectorUC self) -> vectorvectorUC
        __init__(vectorvectorUC self, vectorvectorUC other) -> vectorvectorUC
        __init__(vectorvectorUC self, std::vector< std::vector< unsigned char > >::size_type size) -> vectorvectorUC
        __init__(vectorvectorUC self, std::vector< std::vector< unsigned char > >::size_type size, vectorUC value) -> vectorvectorUC
        """
        _pyBasePython.vectorvectorUC_swiginit(self, _pyBasePython.new_vectorvectorUC(*args))
    push_back = _swig_new_instance_method(_pyBasePython.vectorvectorUC_push_back)
    front = _swig_new_instance_method(_pyBasePython.vectorvectorUC_front)
    back = _swig_new_instance_method(_pyBasePython.vectorvectorUC_back)
    assign = _swig_new_instance_method(_pyBasePython.vectorvectorUC_assign)
    resize = _swig_new_instance_method(_pyBasePython.vectorvectorUC_resize)
    insert = _swig_new_instance_method(_pyBasePython.vectorvectorUC_insert)
    reserve = _swig_new_instance_method(_pyBasePython.vectorvectorUC_reserve)
    capacity = _swig_new_instance_method(_pyBasePython.vectorvectorUC_capacity)
    __swig_destroy__ = _pyBasePython.delete_vectorvectorUC

# Register vectorvectorUC in _pyBasePython:
_pyBasePython.vectorvectorUC_swigregister(vectorvectorUC)
class vectorUS(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.vectorUS_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.vectorUS___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.vectorUS___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.vectorUS___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.vectorUS___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.vectorUS___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.vectorUS___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.vectorUS___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.vectorUS___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.vectorUS___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.vectorUS_pop)
    append = _swig_new_instance_method(_pyBasePython.vectorUS_append)
    empty = _swig_new_instance_method(_pyBasePython.vectorUS_empty)
    size = _swig_new_instance_method(_pyBasePython.vectorUS_size)
    swap = _swig_new_instance_method(_pyBasePython.vectorUS_swap)
    begin = _swig_new_instance_method(_pyBasePython.vectorUS_begin)
    end = _swig_new_instance_method(_pyBasePython.vectorUS_end)
    rbegin = _swig_new_instance_method(_pyBasePython.vectorUS_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.vectorUS_rend)
    clear = _swig_new_instance_method(_pyBasePython.vectorUS_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.vectorUS_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.vectorUS_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.vectorUS_erase)

    def __init__(self, *args):
        r"""
        __init__(vectorUS self) -> vectorUS
        __init__(vectorUS self, vectorUS other) -> vectorUS
        __init__(vectorUS self, std::vector< unsigned short >::size_type size) -> vectorUS
        __init__(vectorUS self, std::vector< unsigned short >::size_type size, std::vector< unsigned short >::value_type const & value) -> vectorUS
        """
        _pyBasePython.vectorUS_swiginit(self, _pyBasePython.new_vectorUS(*args))
    push_back = _swig_new_instance_method(_pyBasePython.vectorUS_push_back)
    front = _swig_new_instance_method(_pyBasePython.vectorUS_front)
    back = _swig_new_instance_method(_pyBasePython.vectorUS_back)
    assign = _swig_new_instance_method(_pyBasePython.vectorUS_assign)
    resize = _swig_new_instance_method(_pyBasePython.vectorUS_resize)
    insert = _swig_new_instance_method(_pyBasePython.vectorUS_insert)
    reserve = _swig_new_instance_method(_pyBasePython.vectorUS_reserve)
    capacity = _swig_new_instance_method(_pyBasePython.vectorUS_capacity)
    __swig_destroy__ = _pyBasePython.delete_vectorUS

# Register vectorUS in _pyBasePython:
_pyBasePython.vectorUS_swigregister(vectorUS)
class vectorvectorUS(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.vectorvectorUS_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.vectorvectorUS___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.vectorvectorUS___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.vectorvectorUS___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.vectorvectorUS___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.vectorvectorUS___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.vectorvectorUS___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.vectorvectorUS___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.vectorvectorUS___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.vectorvectorUS___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.vectorvectorUS_pop)
    append = _swig_new_instance_method(_pyBasePython.vectorvectorUS_append)
    empty = _swig_new_instance_method(_pyBasePython.vectorvectorUS_empty)
    size = _swig_new_instance_method(_pyBasePython.vectorvectorUS_size)
    swap = _swig_new_instance_method(_pyBasePython.vectorvectorUS_swap)
    begin = _swig_new_instance_method(_pyBasePython.vectorvectorUS_begin)
    end = _swig_new_instance_method(_pyBasePython.vectorvectorUS_end)
    rbegin = _swig_new_instance_method(_pyBasePython.vectorvectorUS_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.vectorvectorUS_rend)
    clear = _swig_new_instance_method(_pyBasePython.vectorvectorUS_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.vectorvectorUS_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.vectorvectorUS_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.vectorvectorUS_erase)

    def __init__(self, *args):
        r"""
        __init__(vectorvectorUS self) -> vectorvectorUS
        __init__(vectorvectorUS self, vectorvectorUS other) -> vectorvectorUS
        __init__(vectorvectorUS self, std::vector< std::vector< unsigned short > >::size_type size) -> vectorvectorUS
        __init__(vectorvectorUS self, std::vector< std::vector< unsigned short > >::size_type size, vectorUS value) -> vectorvectorUS
        """
        _pyBasePython.vectorvectorUS_swiginit(self, _pyBasePython.new_vectorvectorUS(*args))
    push_back = _swig_new_instance_method(_pyBasePython.vectorvectorUS_push_back)
    front = _swig_new_instance_method(_pyBasePython.vectorvectorUS_front)
    back = _swig_new_instance_method(_pyBasePython.vectorvectorUS_back)
    assign = _swig_new_instance_method(_pyBasePython.vectorvectorUS_assign)
    resize = _swig_new_instance_method(_pyBasePython.vectorvectorUS_resize)
    insert = _swig_new_instance_method(_pyBasePython.vectorvectorUS_insert)
    reserve = _swig_new_instance_method(_pyBasePython.vectorvectorUS_reserve)
    capacity = _swig_new_instance_method(_pyBasePython.vectorvectorUS_capacity)
    __swig_destroy__ = _pyBasePython.delete_vectorvectorUS

# Register vectorvectorUS in _pyBasePython:
_pyBasePython.vectorvectorUS_swigregister(vectorvectorUS)
class vectorUL(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.vectorUL_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.vectorUL___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.vectorUL___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.vectorUL___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.vectorUL___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.vectorUL___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.vectorUL___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.vectorUL___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.vectorUL___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.vectorUL___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.vectorUL_pop)
    append = _swig_new_instance_method(_pyBasePython.vectorUL_append)
    empty = _swig_new_instance_method(_pyBasePython.vectorUL_empty)
    size = _swig_new_instance_method(_pyBasePython.vectorUL_size)
    swap = _swig_new_instance_method(_pyBasePython.vectorUL_swap)
    begin = _swig_new_instance_method(_pyBasePython.vectorUL_begin)
    end = _swig_new_instance_method(_pyBasePython.vectorUL_end)
    rbegin = _swig_new_instance_method(_pyBasePython.vectorUL_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.vectorUL_rend)
    clear = _swig_new_instance_method(_pyBasePython.vectorUL_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.vectorUL_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.vectorUL_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.vectorUL_erase)

    def __init__(self, *args):
        r"""
        __init__(vectorUL self) -> vectorUL
        __init__(vectorUL self, vectorUL other) -> vectorUL
        __init__(vectorUL self, std::vector< unsigned long >::size_type size) -> vectorUL
        __init__(vectorUL self, std::vector< unsigned long >::size_type size, std::vector< unsigned long >::value_type const & value) -> vectorUL
        """
        _pyBasePython.vectorUL_swiginit(self, _pyBasePython.new_vectorUL(*args))
    push_back = _swig_new_instance_method(_pyBasePython.vectorUL_push_back)
    front = _swig_new_instance_method(_pyBasePython.vectorUL_front)
    back = _swig_new_instance_method(_pyBasePython.vectorUL_back)
    assign = _swig_new_instance_method(_pyBasePython.vectorUL_assign)
    resize = _swig_new_instance_method(_pyBasePython.vectorUL_resize)
    insert = _swig_new_instance_method(_pyBasePython.vectorUL_insert)
    reserve = _swig_new_instance_method(_pyBasePython.vectorUL_reserve)
    capacity = _swig_new_instance_method(_pyBasePython.vectorUL_capacity)
    __swig_destroy__ = _pyBasePython.delete_vectorUL

# Register vectorUL in _pyBasePython:
_pyBasePython.vectorUL_swigregister(vectorUL)
class vectorvectorUL(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.vectorvectorUL_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.vectorvectorUL___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.vectorvectorUL___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.vectorvectorUL___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.vectorvectorUL___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.vectorvectorUL___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.vectorvectorUL___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.vectorvectorUL___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.vectorvectorUL___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.vectorvectorUL___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.vectorvectorUL_pop)
    append = _swig_new_instance_method(_pyBasePython.vectorvectorUL_append)
    empty = _swig_new_instance_method(_pyBasePython.vectorvectorUL_empty)
    size = _swig_new_instance_method(_pyBasePython.vectorvectorUL_size)
    swap = _swig_new_instance_method(_pyBasePython.vectorvectorUL_swap)
    begin = _swig_new_instance_method(_pyBasePython.vectorvectorUL_begin)
    end = _swig_new_instance_method(_pyBasePython.vectorvectorUL_end)
    rbegin = _swig_new_instance_method(_pyBasePython.vectorvectorUL_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.vectorvectorUL_rend)
    clear = _swig_new_instance_method(_pyBasePython.vectorvectorUL_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.vectorvectorUL_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.vectorvectorUL_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.vectorvectorUL_erase)

    def __init__(self, *args):
        r"""
        __init__(vectorvectorUL self) -> vectorvectorUL
        __init__(vectorvectorUL self, vectorvectorUL other) -> vectorvectorUL
        __init__(vectorvectorUL self, std::vector< std::vector< unsigned long > >::size_type size) -> vectorvectorUL
        __init__(vectorvectorUL self, std::vector< std::vector< unsigned long > >::size_type size, vectorUL value) -> vectorvectorUL
        """
        _pyBasePython.vectorvectorUL_swiginit(self, _pyBasePython.new_vectorvectorUL(*args))
    push_back = _swig_new_instance_method(_pyBasePython.vectorvectorUL_push_back)
    front = _swig_new_instance_method(_pyBasePython.vectorvectorUL_front)
    back = _swig_new_instance_method(_pyBasePython.vectorvectorUL_back)
    assign = _swig_new_instance_method(_pyBasePython.vectorvectorUL_assign)
    resize = _swig_new_instance_method(_pyBasePython.vectorvectorUL_resize)
    insert = _swig_new_instance_method(_pyBasePython.vectorvectorUL_insert)
    reserve = _swig_new_instance_method(_pyBasePython.vectorvectorUL_reserve)
    capacity = _swig_new_instance_method(_pyBasePython.vectorvectorUL_capacity)
    __swig_destroy__ = _pyBasePython.delete_vectorvectorUL

# Register vectorvectorUL in _pyBasePython:
_pyBasePython.vectorvectorUL_swigregister(vectorvectorUL)
class vectorSC(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.vectorSC_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.vectorSC___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.vectorSC___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.vectorSC___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.vectorSC___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.vectorSC___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.vectorSC___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.vectorSC___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.vectorSC___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.vectorSC___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.vectorSC_pop)
    append = _swig_new_instance_method(_pyBasePython.vectorSC_append)
    empty = _swig_new_instance_method(_pyBasePython.vectorSC_empty)
    size = _swig_new_instance_method(_pyBasePython.vectorSC_size)
    swap = _swig_new_instance_method(_pyBasePython.vectorSC_swap)
    begin = _swig_new_instance_method(_pyBasePython.vectorSC_begin)
    end = _swig_new_instance_method(_pyBasePython.vectorSC_end)
    rbegin = _swig_new_instance_method(_pyBasePython.vectorSC_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.vectorSC_rend)
    clear = _swig_new_instance_method(_pyBasePython.vectorSC_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.vectorSC_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.vectorSC_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.vectorSC_erase)

    def __init__(self, *args):
        r"""
        __init__(vectorSC self) -> vectorSC
        __init__(vectorSC self, vectorSC other) -> vectorSC
        __init__(vectorSC self, std::vector< signed char >::size_type size) -> vectorSC
        __init__(vectorSC self, std::vector< signed char >::size_type size, std::vector< signed char >::value_type const & value) -> vectorSC
        """
        _pyBasePython.vectorSC_swiginit(self, _pyBasePython.new_vectorSC(*args))
    push_back = _swig_new_instance_method(_pyBasePython.vectorSC_push_back)
    front = _swig_new_instance_method(_pyBasePython.vectorSC_front)
    back = _swig_new_instance_method(_pyBasePython.vectorSC_back)
    assign = _swig_new_instance_method(_pyBasePython.vectorSC_assign)
    resize = _swig_new_instance_method(_pyBasePython.vectorSC_resize)
    insert = _swig_new_instance_method(_pyBasePython.vectorSC_insert)
    reserve = _swig_new_instance_method(_pyBasePython.vectorSC_reserve)
    capacity = _swig_new_instance_method(_pyBasePython.vectorSC_capacity)
    __swig_destroy__ = _pyBasePython.delete_vectorSC

# Register vectorSC in _pyBasePython:
_pyBasePython.vectorSC_swigregister(vectorSC)
class vectorvectorSC(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.vectorvectorSC_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.vectorvectorSC___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.vectorvectorSC___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.vectorvectorSC___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.vectorvectorSC___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.vectorvectorSC___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.vectorvectorSC___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.vectorvectorSC___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.vectorvectorSC___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.vectorvectorSC___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.vectorvectorSC_pop)
    append = _swig_new_instance_method(_pyBasePython.vectorvectorSC_append)
    empty = _swig_new_instance_method(_pyBasePython.vectorvectorSC_empty)
    size = _swig_new_instance_method(_pyBasePython.vectorvectorSC_size)
    swap = _swig_new_instance_method(_pyBasePython.vectorvectorSC_swap)
    begin = _swig_new_instance_method(_pyBasePython.vectorvectorSC_begin)
    end = _swig_new_instance_method(_pyBasePython.vectorvectorSC_end)
    rbegin = _swig_new_instance_method(_pyBasePython.vectorvectorSC_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.vectorvectorSC_rend)
    clear = _swig_new_instance_method(_pyBasePython.vectorvectorSC_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.vectorvectorSC_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.vectorvectorSC_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.vectorvectorSC_erase)

    def __init__(self, *args):
        r"""
        __init__(vectorvectorSC self) -> vectorvectorSC
        __init__(vectorvectorSC self, vectorvectorSC other) -> vectorvectorSC
        __init__(vectorvectorSC self, std::vector< std::vector< signed char > >::size_type size) -> vectorvectorSC
        __init__(vectorvectorSC self, std::vector< std::vector< signed char > >::size_type size, vectorSC value) -> vectorvectorSC
        """
        _pyBasePython.vectorvectorSC_swiginit(self, _pyBasePython.new_vectorvectorSC(*args))
    push_back = _swig_new_instance_method(_pyBasePython.vectorvectorSC_push_back)
    front = _swig_new_instance_method(_pyBasePython.vectorvectorSC_front)
    back = _swig_new_instance_method(_pyBasePython.vectorvectorSC_back)
    assign = _swig_new_instance_method(_pyBasePython.vectorvectorSC_assign)
    resize = _swig_new_instance_method(_pyBasePython.vectorvectorSC_resize)
    insert = _swig_new_instance_method(_pyBasePython.vectorvectorSC_insert)
    reserve = _swig_new_instance_method(_pyBasePython.vectorvectorSC_reserve)
    capacity = _swig_new_instance_method(_pyBasePython.vectorvectorSC_capacity)
    __swig_destroy__ = _pyBasePython.delete_vectorvectorSC

# Register vectorvectorSC in _pyBasePython:
_pyBasePython.vectorvectorSC_swigregister(vectorvectorSC)
class vectorSS(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.vectorSS_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.vectorSS___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.vectorSS___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.vectorSS___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.vectorSS___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.vectorSS___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.vectorSS___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.vectorSS___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.vectorSS___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.vectorSS___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.vectorSS_pop)
    append = _swig_new_instance_method(_pyBasePython.vectorSS_append)
    empty = _swig_new_instance_method(_pyBasePython.vectorSS_empty)
    size = _swig_new_instance_method(_pyBasePython.vectorSS_size)
    swap = _swig_new_instance_method(_pyBasePython.vectorSS_swap)
    begin = _swig_new_instance_method(_pyBasePython.vectorSS_begin)
    end = _swig_new_instance_method(_pyBasePython.vectorSS_end)
    rbegin = _swig_new_instance_method(_pyBasePython.vectorSS_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.vectorSS_rend)
    clear = _swig_new_instance_method(_pyBasePython.vectorSS_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.vectorSS_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.vectorSS_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.vectorSS_erase)

    def __init__(self, *args):
        r"""
        __init__(vectorSS self) -> vectorSS
        __init__(vectorSS self, vectorSS other) -> vectorSS
        __init__(vectorSS self, std::vector< short >::size_type size) -> vectorSS
        __init__(vectorSS self, std::vector< short >::size_type size, std::vector< short >::value_type const & value) -> vectorSS
        """
        _pyBasePython.vectorSS_swiginit(self, _pyBasePython.new_vectorSS(*args))
    push_back = _swig_new_instance_method(_pyBasePython.vectorSS_push_back)
    front = _swig_new_instance_method(_pyBasePython.vectorSS_front)
    back = _swig_new_instance_method(_pyBasePython.vectorSS_back)
    assign = _swig_new_instance_method(_pyBasePython.vectorSS_assign)
    resize = _swig_new_instance_method(_pyBasePython.vectorSS_resize)
    insert = _swig_new_instance_method(_pyBasePython.vectorSS_insert)
    reserve = _swig_new_instance_method(_pyBasePython.vectorSS_reserve)
    capacity = _swig_new_instance_method(_pyBasePython.vectorSS_capacity)
    __swig_destroy__ = _pyBasePython.delete_vectorSS

# Register vectorSS in _pyBasePython:
_pyBasePython.vectorSS_swigregister(vectorSS)
class vectorvectorSS(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.vectorvectorSS_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.vectorvectorSS___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.vectorvectorSS___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.vectorvectorSS___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.vectorvectorSS___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.vectorvectorSS___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.vectorvectorSS___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.vectorvectorSS___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.vectorvectorSS___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.vectorvectorSS___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.vectorvectorSS_pop)
    append = _swig_new_instance_method(_pyBasePython.vectorvectorSS_append)
    empty = _swig_new_instance_method(_pyBasePython.vectorvectorSS_empty)
    size = _swig_new_instance_method(_pyBasePython.vectorvectorSS_size)
    swap = _swig_new_instance_method(_pyBasePython.vectorvectorSS_swap)
    begin = _swig_new_instance_method(_pyBasePython.vectorvectorSS_begin)
    end = _swig_new_instance_method(_pyBasePython.vectorvectorSS_end)
    rbegin = _swig_new_instance_method(_pyBasePython.vectorvectorSS_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.vectorvectorSS_rend)
    clear = _swig_new_instance_method(_pyBasePython.vectorvectorSS_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.vectorvectorSS_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.vectorvectorSS_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.vectorvectorSS_erase)

    def __init__(self, *args):
        r"""
        __init__(vectorvectorSS self) -> vectorvectorSS
        __init__(vectorvectorSS self, vectorvectorSS other) -> vectorvectorSS
        __init__(vectorvectorSS self, std::vector< std::vector< short > >::size_type size) -> vectorvectorSS
        __init__(vectorvectorSS self, std::vector< std::vector< short > >::size_type size, vectorSS value) -> vectorvectorSS
        """
        _pyBasePython.vectorvectorSS_swiginit(self, _pyBasePython.new_vectorvectorSS(*args))
    push_back = _swig_new_instance_method(_pyBasePython.vectorvectorSS_push_back)
    front = _swig_new_instance_method(_pyBasePython.vectorvectorSS_front)
    back = _swig_new_instance_method(_pyBasePython.vectorvectorSS_back)
    assign = _swig_new_instance_method(_pyBasePython.vectorvectorSS_assign)
    resize = _swig_new_instance_method(_pyBasePython.vectorvectorSS_resize)
    insert = _swig_new_instance_method(_pyBasePython.vectorvectorSS_insert)
    reserve = _swig_new_instance_method(_pyBasePython.vectorvectorSS_reserve)
    capacity = _swig_new_instance_method(_pyBasePython.vectorvectorSS_capacity)
    __swig_destroy__ = _pyBasePython.delete_vectorvectorSS

# Register vectorvectorSS in _pyBasePython:
_pyBasePython.vectorvectorSS_swigregister(vectorvectorSS)
class vectorSL(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.vectorSL_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.vectorSL___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.vectorSL___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.vectorSL___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.vectorSL___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.vectorSL___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.vectorSL___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.vectorSL___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.vectorSL___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.vectorSL___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.vectorSL_pop)
    append = _swig_new_instance_method(_pyBasePython.vectorSL_append)
    empty = _swig_new_instance_method(_pyBasePython.vectorSL_empty)
    size = _swig_new_instance_method(_pyBasePython.vectorSL_size)
    swap = _swig_new_instance_method(_pyBasePython.vectorSL_swap)
    begin = _swig_new_instance_method(_pyBasePython.vectorSL_begin)
    end = _swig_new_instance_method(_pyBasePython.vectorSL_end)
    rbegin = _swig_new_instance_method(_pyBasePython.vectorSL_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.vectorSL_rend)
    clear = _swig_new_instance_method(_pyBasePython.vectorSL_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.vectorSL_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.vectorSL_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.vectorSL_erase)

    def __init__(self, *args):
        r"""
        __init__(vectorSL self) -> vectorSL
        __init__(vectorSL self, vectorSL other) -> vectorSL
        __init__(vectorSL self, std::vector< long >::size_type size) -> vectorSL
        __init__(vectorSL self, std::vector< long >::size_type size, std::vector< long >::value_type const & value) -> vectorSL
        """
        _pyBasePython.vectorSL_swiginit(self, _pyBasePython.new_vectorSL(*args))
    push_back = _swig_new_instance_method(_pyBasePython.vectorSL_push_back)
    front = _swig_new_instance_method(_pyBasePython.vectorSL_front)
    back = _swig_new_instance_method(_pyBasePython.vectorSL_back)
    assign = _swig_new_instance_method(_pyBasePython.vectorSL_assign)
    resize = _swig_new_instance_method(_pyBasePython.vectorSL_resize)
    insert = _swig_new_instance_method(_pyBasePython.vectorSL_insert)
    reserve = _swig_new_instance_method(_pyBasePython.vectorSL_reserve)
    capacity = _swig_new_instance_method(_pyBasePython.vectorSL_capacity)
    __swig_destroy__ = _pyBasePython.delete_vectorSL

# Register vectorSL in _pyBasePython:
_pyBasePython.vectorSL_swigregister(vectorSL)
class vectorvectorSL(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.vectorvectorSL_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.vectorvectorSL___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.vectorvectorSL___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.vectorvectorSL___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.vectorvectorSL___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.vectorvectorSL___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.vectorvectorSL___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.vectorvectorSL___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.vectorvectorSL___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.vectorvectorSL___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.vectorvectorSL_pop)
    append = _swig_new_instance_method(_pyBasePython.vectorvectorSL_append)
    empty = _swig_new_instance_method(_pyBasePython.vectorvectorSL_empty)
    size = _swig_new_instance_method(_pyBasePython.vectorvectorSL_size)
    swap = _swig_new_instance_method(_pyBasePython.vectorvectorSL_swap)
    begin = _swig_new_instance_method(_pyBasePython.vectorvectorSL_begin)
    end = _swig_new_instance_method(_pyBasePython.vectorvectorSL_end)
    rbegin = _swig_new_instance_method(_pyBasePython.vectorvectorSL_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.vectorvectorSL_rend)
    clear = _swig_new_instance_method(_pyBasePython.vectorvectorSL_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.vectorvectorSL_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.vectorvectorSL_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.vectorvectorSL_erase)

    def __init__(self, *args):
        r"""
        __init__(vectorvectorSL self) -> vectorvectorSL
        __init__(vectorvectorSL self, vectorvectorSL other) -> vectorvectorSL
        __init__(vectorvectorSL self, std::vector< std::vector< long > >::size_type size) -> vectorvectorSL
        __init__(vectorvectorSL self, std::vector< std::vector< long > >::size_type size, vectorSL value) -> vectorvectorSL
        """
        _pyBasePython.vectorvectorSL_swiginit(self, _pyBasePython.new_vectorvectorSL(*args))
    push_back = _swig_new_instance_method(_pyBasePython.vectorvectorSL_push_back)
    front = _swig_new_instance_method(_pyBasePython.vectorvectorSL_front)
    back = _swig_new_instance_method(_pyBasePython.vectorvectorSL_back)
    assign = _swig_new_instance_method(_pyBasePython.vectorvectorSL_assign)
    resize = _swig_new_instance_method(_pyBasePython.vectorvectorSL_resize)
    insert = _swig_new_instance_method(_pyBasePython.vectorvectorSL_insert)
    reserve = _swig_new_instance_method(_pyBasePython.vectorvectorSL_reserve)
    capacity = _swig_new_instance_method(_pyBasePython.vectorvectorSL_capacity)
    __swig_destroy__ = _pyBasePython.delete_vectorvectorSL

# Register vectorvectorSL in _pyBasePython:
_pyBasePython.vectorvectorSL_swigregister(vectorvectorSL)
class vectorF(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.vectorF_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.vectorF___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.vectorF___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.vectorF___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.vectorF___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.vectorF___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.vectorF___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.vectorF___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.vectorF___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.vectorF___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.vectorF_pop)
    append = _swig_new_instance_method(_pyBasePython.vectorF_append)
    empty = _swig_new_instance_method(_pyBasePython.vectorF_empty)
    size = _swig_new_instance_method(_pyBasePython.vectorF_size)
    swap = _swig_new_instance_method(_pyBasePython.vectorF_swap)
    begin = _swig_new_instance_method(_pyBasePython.vectorF_begin)
    end = _swig_new_instance_method(_pyBasePython.vectorF_end)
    rbegin = _swig_new_instance_method(_pyBasePython.vectorF_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.vectorF_rend)
    clear = _swig_new_instance_method(_pyBasePython.vectorF_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.vectorF_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.vectorF_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.vectorF_erase)

    def __init__(self, *args):
        r"""
        __init__(vectorF self) -> vectorF
        __init__(vectorF self, vectorF other) -> vectorF
        __init__(vectorF self, std::vector< float >::size_type size) -> vectorF
        __init__(vectorF self, std::vector< float >::size_type size, std::vector< float >::value_type const & value) -> vectorF
        """
        _pyBasePython.vectorF_swiginit(self, _pyBasePython.new_vectorF(*args))
    push_back = _swig_new_instance_method(_pyBasePython.vectorF_push_back)
    front = _swig_new_instance_method(_pyBasePython.vectorF_front)
    back = _swig_new_instance_method(_pyBasePython.vectorF_back)
    assign = _swig_new_instance_method(_pyBasePython.vectorF_assign)
    resize = _swig_new_instance_method(_pyBasePython.vectorF_resize)
    insert = _swig_new_instance_method(_pyBasePython.vectorF_insert)
    reserve = _swig_new_instance_method(_pyBasePython.vectorF_reserve)
    capacity = _swig_new_instance_method(_pyBasePython.vectorF_capacity)
    __swig_destroy__ = _pyBasePython.delete_vectorF

# Register vectorF in _pyBasePython:
_pyBasePython.vectorF_swigregister(vectorF)
class vectorvectorF(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.vectorvectorF_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.vectorvectorF___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.vectorvectorF___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.vectorvectorF___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.vectorvectorF___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.vectorvectorF___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.vectorvectorF___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.vectorvectorF___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.vectorvectorF___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.vectorvectorF___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.vectorvectorF_pop)
    append = _swig_new_instance_method(_pyBasePython.vectorvectorF_append)
    empty = _swig_new_instance_method(_pyBasePython.vectorvectorF_empty)
    size = _swig_new_instance_method(_pyBasePython.vectorvectorF_size)
    swap = _swig_new_instance_method(_pyBasePython.vectorvectorF_swap)
    begin = _swig_new_instance_method(_pyBasePython.vectorvectorF_begin)
    end = _swig_new_instance_method(_pyBasePython.vectorvectorF_end)
    rbegin = _swig_new_instance_method(_pyBasePython.vectorvectorF_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.vectorvectorF_rend)
    clear = _swig_new_instance_method(_pyBasePython.vectorvectorF_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.vectorvectorF_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.vectorvectorF_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.vectorvectorF_erase)

    def __init__(self, *args):
        r"""
        __init__(vectorvectorF self) -> vectorvectorF
        __init__(vectorvectorF self, vectorvectorF other) -> vectorvectorF
        __init__(vectorvectorF self, std::vector< std::vector< float > >::size_type size) -> vectorvectorF
        __init__(vectorvectorF self, std::vector< std::vector< float > >::size_type size, vectorF value) -> vectorvectorF
        """
        _pyBasePython.vectorvectorF_swiginit(self, _pyBasePython.new_vectorvectorF(*args))
    push_back = _swig_new_instance_method(_pyBasePython.vectorvectorF_push_back)
    front = _swig_new_instance_method(_pyBasePython.vectorvectorF_front)
    back = _swig_new_instance_method(_pyBasePython.vectorvectorF_back)
    assign = _swig_new_instance_method(_pyBasePython.vectorvectorF_assign)
    resize = _swig_new_instance_method(_pyBasePython.vectorvectorF_resize)
    insert = _swig_new_instance_method(_pyBasePython.vectorvectorF_insert)
    reserve = _swig_new_instance_method(_pyBasePython.vectorvectorF_reserve)
    capacity = _swig_new_instance_method(_pyBasePython.vectorvectorF_capacity)
    __swig_destroy__ = _pyBasePython.delete_vectorvectorF

# Register vectorvectorF in _pyBasePython:
_pyBasePython.vectorvectorF_swigregister(vectorvectorF)
class vectorD(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.vectorD_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.vectorD___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.vectorD___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.vectorD___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.vectorD___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.vectorD___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.vectorD___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.vectorD___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.vectorD___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.vectorD___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.vectorD_pop)
    append = _swig_new_instance_method(_pyBasePython.vectorD_append)
    empty = _swig_new_instance_method(_pyBasePython.vectorD_empty)
    size = _swig_new_instance_method(_pyBasePython.vectorD_size)
    swap = _swig_new_instance_method(_pyBasePython.vectorD_swap)
    begin = _swig_new_instance_method(_pyBasePython.vectorD_begin)
    end = _swig_new_instance_method(_pyBasePython.vectorD_end)
    rbegin = _swig_new_instance_method(_pyBasePython.vectorD_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.vectorD_rend)
    clear = _swig_new_instance_method(_pyBasePython.vectorD_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.vectorD_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.vectorD_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.vectorD_erase)

    def __init__(self, *args):
        r"""
        __init__(vectorD self) -> vectorD
        __init__(vectorD self, vectorD other) -> vectorD
        __init__(vectorD self, std::vector< double >::size_type size) -> vectorD
        __init__(vectorD self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> vectorD
        """
        _pyBasePython.vectorD_swiginit(self, _pyBasePython.new_vectorD(*args))
    push_back = _swig_new_instance_method(_pyBasePython.vectorD_push_back)
    front = _swig_new_instance_method(_pyBasePython.vectorD_front)
    back = _swig_new_instance_method(_pyBasePython.vectorD_back)
    assign = _swig_new_instance_method(_pyBasePython.vectorD_assign)
    resize = _swig_new_instance_method(_pyBasePython.vectorD_resize)
    insert = _swig_new_instance_method(_pyBasePython.vectorD_insert)
    reserve = _swig_new_instance_method(_pyBasePython.vectorD_reserve)
    capacity = _swig_new_instance_method(_pyBasePython.vectorD_capacity)
    __swig_destroy__ = _pyBasePython.delete_vectorD

# Register vectorD in _pyBasePython:
_pyBasePython.vectorD_swigregister(vectorD)
class vectorvectorD(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.vectorvectorD_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.vectorvectorD___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.vectorvectorD___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.vectorvectorD___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.vectorvectorD___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.vectorvectorD___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.vectorvectorD___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.vectorvectorD___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.vectorvectorD___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.vectorvectorD___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.vectorvectorD_pop)
    append = _swig_new_instance_method(_pyBasePython.vectorvectorD_append)
    empty = _swig_new_instance_method(_pyBasePython.vectorvectorD_empty)
    size = _swig_new_instance_method(_pyBasePython.vectorvectorD_size)
    swap = _swig_new_instance_method(_pyBasePython.vectorvectorD_swap)
    begin = _swig_new_instance_method(_pyBasePython.vectorvectorD_begin)
    end = _swig_new_instance_method(_pyBasePython.vectorvectorD_end)
    rbegin = _swig_new_instance_method(_pyBasePython.vectorvectorD_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.vectorvectorD_rend)
    clear = _swig_new_instance_method(_pyBasePython.vectorvectorD_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.vectorvectorD_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.vectorvectorD_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.vectorvectorD_erase)

    def __init__(self, *args):
        r"""
        __init__(vectorvectorD self) -> vectorvectorD
        __init__(vectorvectorD self, vectorvectorD other) -> vectorvectorD
        __init__(vectorvectorD self, std::vector< std::vector< double > >::size_type size) -> vectorvectorD
        __init__(vectorvectorD self, std::vector< std::vector< double > >::size_type size, vectorD value) -> vectorvectorD
        """
        _pyBasePython.vectorvectorD_swiginit(self, _pyBasePython.new_vectorvectorD(*args))
    push_back = _swig_new_instance_method(_pyBasePython.vectorvectorD_push_back)
    front = _swig_new_instance_method(_pyBasePython.vectorvectorD_front)
    back = _swig_new_instance_method(_pyBasePython.vectorvectorD_back)
    assign = _swig_new_instance_method(_pyBasePython.vectorvectorD_assign)
    resize = _swig_new_instance_method(_pyBasePython.vectorvectorD_resize)
    insert = _swig_new_instance_method(_pyBasePython.vectorvectorD_insert)
    reserve = _swig_new_instance_method(_pyBasePython.vectorvectorD_reserve)
    capacity = _swig_new_instance_method(_pyBasePython.vectorvectorD_capacity)
    __swig_destroy__ = _pyBasePython.delete_vectorvectorD

# Register vectorvectorD in _pyBasePython:
_pyBasePython.vectorvectorD_swigregister(vectorvectorD)
class listB(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.listB_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.listB___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.listB___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.listB___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.listB___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.listB___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.listB___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.listB___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.listB___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.listB___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.listB_pop)
    append = _swig_new_instance_method(_pyBasePython.listB_append)
    empty = _swig_new_instance_method(_pyBasePython.listB_empty)
    size = _swig_new_instance_method(_pyBasePython.listB_size)
    swap = _swig_new_instance_method(_pyBasePython.listB_swap)
    begin = _swig_new_instance_method(_pyBasePython.listB_begin)
    end = _swig_new_instance_method(_pyBasePython.listB_end)
    rbegin = _swig_new_instance_method(_pyBasePython.listB_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.listB_rend)
    clear = _swig_new_instance_method(_pyBasePython.listB_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.listB_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.listB_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.listB_erase)

    def __init__(self, *args):
        r"""
        __init__(listB self) -> listB
        __init__(listB self, listB other) -> listB
        __init__(listB self, std::list< bool >::size_type size) -> listB
        __init__(listB self, std::list< bool >::size_type size, std::list< bool >::value_type const & value) -> listB
        """
        _pyBasePython.listB_swiginit(self, _pyBasePython.new_listB(*args))
    push_back = _swig_new_instance_method(_pyBasePython.listB_push_back)
    front = _swig_new_instance_method(_pyBasePython.listB_front)
    back = _swig_new_instance_method(_pyBasePython.listB_back)
    assign = _swig_new_instance_method(_pyBasePython.listB_assign)
    resize = _swig_new_instance_method(_pyBasePython.listB_resize)
    insert = _swig_new_instance_method(_pyBasePython.listB_insert)
    pop_front = _swig_new_instance_method(_pyBasePython.listB_pop_front)
    push_front = _swig_new_instance_method(_pyBasePython.listB_push_front)
    reverse = _swig_new_instance_method(_pyBasePython.listB_reverse)
    __swig_destroy__ = _pyBasePython.delete_listB

# Register listB in _pyBasePython:
_pyBasePython.listB_swigregister(listB)
class listUC(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.listUC_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.listUC___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.listUC___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.listUC___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.listUC___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.listUC___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.listUC___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.listUC___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.listUC___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.listUC___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.listUC_pop)
    append = _swig_new_instance_method(_pyBasePython.listUC_append)
    empty = _swig_new_instance_method(_pyBasePython.listUC_empty)
    size = _swig_new_instance_method(_pyBasePython.listUC_size)
    swap = _swig_new_instance_method(_pyBasePython.listUC_swap)
    begin = _swig_new_instance_method(_pyBasePython.listUC_begin)
    end = _swig_new_instance_method(_pyBasePython.listUC_end)
    rbegin = _swig_new_instance_method(_pyBasePython.listUC_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.listUC_rend)
    clear = _swig_new_instance_method(_pyBasePython.listUC_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.listUC_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.listUC_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.listUC_erase)

    def __init__(self, *args):
        r"""
        __init__(listUC self) -> listUC
        __init__(listUC self, listUC other) -> listUC
        __init__(listUC self, std::list< unsigned char >::size_type size) -> listUC
        __init__(listUC self, std::list< unsigned char >::size_type size, std::list< unsigned char >::value_type const & value) -> listUC
        """
        _pyBasePython.listUC_swiginit(self, _pyBasePython.new_listUC(*args))
    push_back = _swig_new_instance_method(_pyBasePython.listUC_push_back)
    front = _swig_new_instance_method(_pyBasePython.listUC_front)
    back = _swig_new_instance_method(_pyBasePython.listUC_back)
    assign = _swig_new_instance_method(_pyBasePython.listUC_assign)
    resize = _swig_new_instance_method(_pyBasePython.listUC_resize)
    insert = _swig_new_instance_method(_pyBasePython.listUC_insert)
    pop_front = _swig_new_instance_method(_pyBasePython.listUC_pop_front)
    push_front = _swig_new_instance_method(_pyBasePython.listUC_push_front)
    reverse = _swig_new_instance_method(_pyBasePython.listUC_reverse)
    __swig_destroy__ = _pyBasePython.delete_listUC

# Register listUC in _pyBasePython:
_pyBasePython.listUC_swigregister(listUC)
class listUS(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.listUS_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.listUS___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.listUS___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.listUS___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.listUS___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.listUS___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.listUS___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.listUS___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.listUS___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.listUS___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.listUS_pop)
    append = _swig_new_instance_method(_pyBasePython.listUS_append)
    empty = _swig_new_instance_method(_pyBasePython.listUS_empty)
    size = _swig_new_instance_method(_pyBasePython.listUS_size)
    swap = _swig_new_instance_method(_pyBasePython.listUS_swap)
    begin = _swig_new_instance_method(_pyBasePython.listUS_begin)
    end = _swig_new_instance_method(_pyBasePython.listUS_end)
    rbegin = _swig_new_instance_method(_pyBasePython.listUS_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.listUS_rend)
    clear = _swig_new_instance_method(_pyBasePython.listUS_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.listUS_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.listUS_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.listUS_erase)

    def __init__(self, *args):
        r"""
        __init__(listUS self) -> listUS
        __init__(listUS self, listUS other) -> listUS
        __init__(listUS self, std::list< unsigned short >::size_type size) -> listUS
        __init__(listUS self, std::list< unsigned short >::size_type size, std::list< unsigned short >::value_type const & value) -> listUS
        """
        _pyBasePython.listUS_swiginit(self, _pyBasePython.new_listUS(*args))
    push_back = _swig_new_instance_method(_pyBasePython.listUS_push_back)
    front = _swig_new_instance_method(_pyBasePython.listUS_front)
    back = _swig_new_instance_method(_pyBasePython.listUS_back)
    assign = _swig_new_instance_method(_pyBasePython.listUS_assign)
    resize = _swig_new_instance_method(_pyBasePython.listUS_resize)
    insert = _swig_new_instance_method(_pyBasePython.listUS_insert)
    pop_front = _swig_new_instance_method(_pyBasePython.listUS_pop_front)
    push_front = _swig_new_instance_method(_pyBasePython.listUS_push_front)
    reverse = _swig_new_instance_method(_pyBasePython.listUS_reverse)
    __swig_destroy__ = _pyBasePython.delete_listUS

# Register listUS in _pyBasePython:
_pyBasePython.listUS_swigregister(listUS)
class listUL(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.listUL_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.listUL___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.listUL___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.listUL___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.listUL___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.listUL___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.listUL___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.listUL___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.listUL___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.listUL___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.listUL_pop)
    append = _swig_new_instance_method(_pyBasePython.listUL_append)
    empty = _swig_new_instance_method(_pyBasePython.listUL_empty)
    size = _swig_new_instance_method(_pyBasePython.listUL_size)
    swap = _swig_new_instance_method(_pyBasePython.listUL_swap)
    begin = _swig_new_instance_method(_pyBasePython.listUL_begin)
    end = _swig_new_instance_method(_pyBasePython.listUL_end)
    rbegin = _swig_new_instance_method(_pyBasePython.listUL_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.listUL_rend)
    clear = _swig_new_instance_method(_pyBasePython.listUL_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.listUL_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.listUL_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.listUL_erase)

    def __init__(self, *args):
        r"""
        __init__(listUL self) -> listUL
        __init__(listUL self, listUL other) -> listUL
        __init__(listUL self, std::list< unsigned long >::size_type size) -> listUL
        __init__(listUL self, std::list< unsigned long >::size_type size, std::list< unsigned long >::value_type const & value) -> listUL
        """
        _pyBasePython.listUL_swiginit(self, _pyBasePython.new_listUL(*args))
    push_back = _swig_new_instance_method(_pyBasePython.listUL_push_back)
    front = _swig_new_instance_method(_pyBasePython.listUL_front)
    back = _swig_new_instance_method(_pyBasePython.listUL_back)
    assign = _swig_new_instance_method(_pyBasePython.listUL_assign)
    resize = _swig_new_instance_method(_pyBasePython.listUL_resize)
    insert = _swig_new_instance_method(_pyBasePython.listUL_insert)
    pop_front = _swig_new_instance_method(_pyBasePython.listUL_pop_front)
    push_front = _swig_new_instance_method(_pyBasePython.listUL_push_front)
    reverse = _swig_new_instance_method(_pyBasePython.listUL_reverse)
    __swig_destroy__ = _pyBasePython.delete_listUL

# Register listUL in _pyBasePython:
_pyBasePython.listUL_swigregister(listUL)
class listSC(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.listSC_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.listSC___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.listSC___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.listSC___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.listSC___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.listSC___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.listSC___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.listSC___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.listSC___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.listSC___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.listSC_pop)
    append = _swig_new_instance_method(_pyBasePython.listSC_append)
    empty = _swig_new_instance_method(_pyBasePython.listSC_empty)
    size = _swig_new_instance_method(_pyBasePython.listSC_size)
    swap = _swig_new_instance_method(_pyBasePython.listSC_swap)
    begin = _swig_new_instance_method(_pyBasePython.listSC_begin)
    end = _swig_new_instance_method(_pyBasePython.listSC_end)
    rbegin = _swig_new_instance_method(_pyBasePython.listSC_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.listSC_rend)
    clear = _swig_new_instance_method(_pyBasePython.listSC_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.listSC_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.listSC_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.listSC_erase)

    def __init__(self, *args):
        r"""
        __init__(listSC self) -> listSC
        __init__(listSC self, listSC other) -> listSC
        __init__(listSC self, std::list< signed char >::size_type size) -> listSC
        __init__(listSC self, std::list< signed char >::size_type size, std::list< signed char >::value_type const & value) -> listSC
        """
        _pyBasePython.listSC_swiginit(self, _pyBasePython.new_listSC(*args))
    push_back = _swig_new_instance_method(_pyBasePython.listSC_push_back)
    front = _swig_new_instance_method(_pyBasePython.listSC_front)
    back = _swig_new_instance_method(_pyBasePython.listSC_back)
    assign = _swig_new_instance_method(_pyBasePython.listSC_assign)
    resize = _swig_new_instance_method(_pyBasePython.listSC_resize)
    insert = _swig_new_instance_method(_pyBasePython.listSC_insert)
    pop_front = _swig_new_instance_method(_pyBasePython.listSC_pop_front)
    push_front = _swig_new_instance_method(_pyBasePython.listSC_push_front)
    reverse = _swig_new_instance_method(_pyBasePython.listSC_reverse)
    __swig_destroy__ = _pyBasePython.delete_listSC

# Register listSC in _pyBasePython:
_pyBasePython.listSC_swigregister(listSC)
class listSS(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.listSS_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.listSS___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.listSS___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.listSS___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.listSS___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.listSS___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.listSS___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.listSS___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.listSS___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.listSS___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.listSS_pop)
    append = _swig_new_instance_method(_pyBasePython.listSS_append)
    empty = _swig_new_instance_method(_pyBasePython.listSS_empty)
    size = _swig_new_instance_method(_pyBasePython.listSS_size)
    swap = _swig_new_instance_method(_pyBasePython.listSS_swap)
    begin = _swig_new_instance_method(_pyBasePython.listSS_begin)
    end = _swig_new_instance_method(_pyBasePython.listSS_end)
    rbegin = _swig_new_instance_method(_pyBasePython.listSS_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.listSS_rend)
    clear = _swig_new_instance_method(_pyBasePython.listSS_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.listSS_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.listSS_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.listSS_erase)

    def __init__(self, *args):
        r"""
        __init__(listSS self) -> listSS
        __init__(listSS self, listSS other) -> listSS
        __init__(listSS self, std::list< short >::size_type size) -> listSS
        __init__(listSS self, std::list< short >::size_type size, std::list< short >::value_type const & value) -> listSS
        """
        _pyBasePython.listSS_swiginit(self, _pyBasePython.new_listSS(*args))
    push_back = _swig_new_instance_method(_pyBasePython.listSS_push_back)
    front = _swig_new_instance_method(_pyBasePython.listSS_front)
    back = _swig_new_instance_method(_pyBasePython.listSS_back)
    assign = _swig_new_instance_method(_pyBasePython.listSS_assign)
    resize = _swig_new_instance_method(_pyBasePython.listSS_resize)
    insert = _swig_new_instance_method(_pyBasePython.listSS_insert)
    pop_front = _swig_new_instance_method(_pyBasePython.listSS_pop_front)
    push_front = _swig_new_instance_method(_pyBasePython.listSS_push_front)
    reverse = _swig_new_instance_method(_pyBasePython.listSS_reverse)
    __swig_destroy__ = _pyBasePython.delete_listSS

# Register listSS in _pyBasePython:
_pyBasePython.listSS_swigregister(listSS)
class listSL(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.listSL_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.listSL___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.listSL___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.listSL___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.listSL___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.listSL___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.listSL___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.listSL___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.listSL___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.listSL___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.listSL_pop)
    append = _swig_new_instance_method(_pyBasePython.listSL_append)
    empty = _swig_new_instance_method(_pyBasePython.listSL_empty)
    size = _swig_new_instance_method(_pyBasePython.listSL_size)
    swap = _swig_new_instance_method(_pyBasePython.listSL_swap)
    begin = _swig_new_instance_method(_pyBasePython.listSL_begin)
    end = _swig_new_instance_method(_pyBasePython.listSL_end)
    rbegin = _swig_new_instance_method(_pyBasePython.listSL_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.listSL_rend)
    clear = _swig_new_instance_method(_pyBasePython.listSL_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.listSL_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.listSL_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.listSL_erase)

    def __init__(self, *args):
        r"""
        __init__(listSL self) -> listSL
        __init__(listSL self, listSL other) -> listSL
        __init__(listSL self, std::list< long >::size_type size) -> listSL
        __init__(listSL self, std::list< long >::size_type size, std::list< long >::value_type const & value) -> listSL
        """
        _pyBasePython.listSL_swiginit(self, _pyBasePython.new_listSL(*args))
    push_back = _swig_new_instance_method(_pyBasePython.listSL_push_back)
    front = _swig_new_instance_method(_pyBasePython.listSL_front)
    back = _swig_new_instance_method(_pyBasePython.listSL_back)
    assign = _swig_new_instance_method(_pyBasePython.listSL_assign)
    resize = _swig_new_instance_method(_pyBasePython.listSL_resize)
    insert = _swig_new_instance_method(_pyBasePython.listSL_insert)
    pop_front = _swig_new_instance_method(_pyBasePython.listSL_pop_front)
    push_front = _swig_new_instance_method(_pyBasePython.listSL_push_front)
    reverse = _swig_new_instance_method(_pyBasePython.listSL_reverse)
    __swig_destroy__ = _pyBasePython.delete_listSL

# Register listSL in _pyBasePython:
_pyBasePython.listSL_swigregister(listSL)
class listF(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.listF_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.listF___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.listF___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.listF___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.listF___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.listF___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.listF___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.listF___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.listF___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.listF___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.listF_pop)
    append = _swig_new_instance_method(_pyBasePython.listF_append)
    empty = _swig_new_instance_method(_pyBasePython.listF_empty)
    size = _swig_new_instance_method(_pyBasePython.listF_size)
    swap = _swig_new_instance_method(_pyBasePython.listF_swap)
    begin = _swig_new_instance_method(_pyBasePython.listF_begin)
    end = _swig_new_instance_method(_pyBasePython.listF_end)
    rbegin = _swig_new_instance_method(_pyBasePython.listF_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.listF_rend)
    clear = _swig_new_instance_method(_pyBasePython.listF_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.listF_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.listF_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.listF_erase)

    def __init__(self, *args):
        r"""
        __init__(listF self) -> listF
        __init__(listF self, listF other) -> listF
        __init__(listF self, std::list< float >::size_type size) -> listF
        __init__(listF self, std::list< float >::size_type size, std::list< float >::value_type const & value) -> listF
        """
        _pyBasePython.listF_swiginit(self, _pyBasePython.new_listF(*args))
    push_back = _swig_new_instance_method(_pyBasePython.listF_push_back)
    front = _swig_new_instance_method(_pyBasePython.listF_front)
    back = _swig_new_instance_method(_pyBasePython.listF_back)
    assign = _swig_new_instance_method(_pyBasePython.listF_assign)
    resize = _swig_new_instance_method(_pyBasePython.listF_resize)
    insert = _swig_new_instance_method(_pyBasePython.listF_insert)
    pop_front = _swig_new_instance_method(_pyBasePython.listF_pop_front)
    push_front = _swig_new_instance_method(_pyBasePython.listF_push_front)
    reverse = _swig_new_instance_method(_pyBasePython.listF_reverse)
    __swig_destroy__ = _pyBasePython.delete_listF

# Register listF in _pyBasePython:
_pyBasePython.listF_swigregister(listF)
class listD(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.listD_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.listD___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.listD___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.listD___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.listD___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.listD___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.listD___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.listD___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.listD___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.listD___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.listD_pop)
    append = _swig_new_instance_method(_pyBasePython.listD_append)
    empty = _swig_new_instance_method(_pyBasePython.listD_empty)
    size = _swig_new_instance_method(_pyBasePython.listD_size)
    swap = _swig_new_instance_method(_pyBasePython.listD_swap)
    begin = _swig_new_instance_method(_pyBasePython.listD_begin)
    end = _swig_new_instance_method(_pyBasePython.listD_end)
    rbegin = _swig_new_instance_method(_pyBasePython.listD_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.listD_rend)
    clear = _swig_new_instance_method(_pyBasePython.listD_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.listD_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.listD_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.listD_erase)

    def __init__(self, *args):
        r"""
        __init__(listD self) -> listD
        __init__(listD self, listD other) -> listD
        __init__(listD self, std::list< double >::size_type size) -> listD
        __init__(listD self, std::list< double >::size_type size, std::list< double >::value_type const & value) -> listD
        """
        _pyBasePython.listD_swiginit(self, _pyBasePython.new_listD(*args))
    push_back = _swig_new_instance_method(_pyBasePython.listD_push_back)
    front = _swig_new_instance_method(_pyBasePython.listD_front)
    back = _swig_new_instance_method(_pyBasePython.listD_back)
    assign = _swig_new_instance_method(_pyBasePython.listD_assign)
    resize = _swig_new_instance_method(_pyBasePython.listD_resize)
    insert = _swig_new_instance_method(_pyBasePython.listD_insert)
    pop_front = _swig_new_instance_method(_pyBasePython.listD_pop_front)
    push_front = _swig_new_instance_method(_pyBasePython.listD_push_front)
    reverse = _swig_new_instance_method(_pyBasePython.listD_reverse)
    __swig_destroy__ = _pyBasePython.delete_listD

# Register listD in _pyBasePython:
_pyBasePython.listD_swigregister(listD)
class setB(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.setB_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.setB___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.setB___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.setB___len__)
    append = _swig_new_instance_method(_pyBasePython.setB_append)
    __contains__ = _swig_new_instance_method(_pyBasePython.setB___contains__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.setB___getitem__)
    add = _swig_new_instance_method(_pyBasePython.setB_add)
    discard = _swig_new_instance_method(_pyBasePython.setB_discard)

    def __init__(self, *args):
        r"""
        __init__(setB self, std::less< bool > const & other) -> setB
        __init__(setB self) -> setB
        __init__(setB self, setB other) -> setB
        """
        _pyBasePython.setB_swiginit(self, _pyBasePython.new_setB(*args))
    empty = _swig_new_instance_method(_pyBasePython.setB_empty)
    size = _swig_new_instance_method(_pyBasePython.setB_size)
    clear = _swig_new_instance_method(_pyBasePython.setB_clear)
    swap = _swig_new_instance_method(_pyBasePython.setB_swap)
    count = _swig_new_instance_method(_pyBasePython.setB_count)
    begin = _swig_new_instance_method(_pyBasePython.setB_begin)
    end = _swig_new_instance_method(_pyBasePython.setB_end)
    rbegin = _swig_new_instance_method(_pyBasePython.setB_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.setB_rend)
    erase = _swig_new_instance_method(_pyBasePython.setB_erase)
    find = _swig_new_instance_method(_pyBasePython.setB_find)
    lower_bound = _swig_new_instance_method(_pyBasePython.setB_lower_bound)
    upper_bound = _swig_new_instance_method(_pyBasePython.setB_upper_bound)
    equal_range = _swig_new_instance_method(_pyBasePython.setB_equal_range)
    insert = _swig_new_instance_method(_pyBasePython.setB_insert)
    __swig_destroy__ = _pyBasePython.delete_setB

# Register setB in _pyBasePython:
_pyBasePython.setB_swigregister(setB)
class setUC(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.setUC_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.setUC___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.setUC___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.setUC___len__)
    append = _swig_new_instance_method(_pyBasePython.setUC_append)
    __contains__ = _swig_new_instance_method(_pyBasePython.setUC___contains__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.setUC___getitem__)
    add = _swig_new_instance_method(_pyBasePython.setUC_add)
    discard = _swig_new_instance_method(_pyBasePython.setUC_discard)

    def __init__(self, *args):
        r"""
        __init__(setUC self, std::less< unsigned char > const & other) -> setUC
        __init__(setUC self) -> setUC
        __init__(setUC self, setUC other) -> setUC
        """
        _pyBasePython.setUC_swiginit(self, _pyBasePython.new_setUC(*args))
    empty = _swig_new_instance_method(_pyBasePython.setUC_empty)
    size = _swig_new_instance_method(_pyBasePython.setUC_size)
    clear = _swig_new_instance_method(_pyBasePython.setUC_clear)
    swap = _swig_new_instance_method(_pyBasePython.setUC_swap)
    count = _swig_new_instance_method(_pyBasePython.setUC_count)
    begin = _swig_new_instance_method(_pyBasePython.setUC_begin)
    end = _swig_new_instance_method(_pyBasePython.setUC_end)
    rbegin = _swig_new_instance_method(_pyBasePython.setUC_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.setUC_rend)
    erase = _swig_new_instance_method(_pyBasePython.setUC_erase)
    find = _swig_new_instance_method(_pyBasePython.setUC_find)
    lower_bound = _swig_new_instance_method(_pyBasePython.setUC_lower_bound)
    upper_bound = _swig_new_instance_method(_pyBasePython.setUC_upper_bound)
    equal_range = _swig_new_instance_method(_pyBasePython.setUC_equal_range)
    insert = _swig_new_instance_method(_pyBasePython.setUC_insert)
    __swig_destroy__ = _pyBasePython.delete_setUC

# Register setUC in _pyBasePython:
_pyBasePython.setUC_swigregister(setUC)
class setUS(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.setUS_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.setUS___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.setUS___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.setUS___len__)
    append = _swig_new_instance_method(_pyBasePython.setUS_append)
    __contains__ = _swig_new_instance_method(_pyBasePython.setUS___contains__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.setUS___getitem__)
    add = _swig_new_instance_method(_pyBasePython.setUS_add)
    discard = _swig_new_instance_method(_pyBasePython.setUS_discard)

    def __init__(self, *args):
        r"""
        __init__(setUS self, std::less< unsigned short > const & other) -> setUS
        __init__(setUS self) -> setUS
        __init__(setUS self, setUS other) -> setUS
        """
        _pyBasePython.setUS_swiginit(self, _pyBasePython.new_setUS(*args))
    empty = _swig_new_instance_method(_pyBasePython.setUS_empty)
    size = _swig_new_instance_method(_pyBasePython.setUS_size)
    clear = _swig_new_instance_method(_pyBasePython.setUS_clear)
    swap = _swig_new_instance_method(_pyBasePython.setUS_swap)
    count = _swig_new_instance_method(_pyBasePython.setUS_count)
    begin = _swig_new_instance_method(_pyBasePython.setUS_begin)
    end = _swig_new_instance_method(_pyBasePython.setUS_end)
    rbegin = _swig_new_instance_method(_pyBasePython.setUS_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.setUS_rend)
    erase = _swig_new_instance_method(_pyBasePython.setUS_erase)
    find = _swig_new_instance_method(_pyBasePython.setUS_find)
    lower_bound = _swig_new_instance_method(_pyBasePython.setUS_lower_bound)
    upper_bound = _swig_new_instance_method(_pyBasePython.setUS_upper_bound)
    equal_range = _swig_new_instance_method(_pyBasePython.setUS_equal_range)
    insert = _swig_new_instance_method(_pyBasePython.setUS_insert)
    __swig_destroy__ = _pyBasePython.delete_setUS

# Register setUS in _pyBasePython:
_pyBasePython.setUS_swigregister(setUS)
class setUL(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.setUL_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.setUL___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.setUL___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.setUL___len__)
    append = _swig_new_instance_method(_pyBasePython.setUL_append)
    __contains__ = _swig_new_instance_method(_pyBasePython.setUL___contains__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.setUL___getitem__)
    add = _swig_new_instance_method(_pyBasePython.setUL_add)
    discard = _swig_new_instance_method(_pyBasePython.setUL_discard)

    def __init__(self, *args):
        r"""
        __init__(setUL self, std::less< unsigned long > const & other) -> setUL
        __init__(setUL self) -> setUL
        __init__(setUL self, setUL other) -> setUL
        """
        _pyBasePython.setUL_swiginit(self, _pyBasePython.new_setUL(*args))
    empty = _swig_new_instance_method(_pyBasePython.setUL_empty)
    size = _swig_new_instance_method(_pyBasePython.setUL_size)
    clear = _swig_new_instance_method(_pyBasePython.setUL_clear)
    swap = _swig_new_instance_method(_pyBasePython.setUL_swap)
    count = _swig_new_instance_method(_pyBasePython.setUL_count)
    begin = _swig_new_instance_method(_pyBasePython.setUL_begin)
    end = _swig_new_instance_method(_pyBasePython.setUL_end)
    rbegin = _swig_new_instance_method(_pyBasePython.setUL_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.setUL_rend)
    erase = _swig_new_instance_method(_pyBasePython.setUL_erase)
    find = _swig_new_instance_method(_pyBasePython.setUL_find)
    lower_bound = _swig_new_instance_method(_pyBasePython.setUL_lower_bound)
    upper_bound = _swig_new_instance_method(_pyBasePython.setUL_upper_bound)
    equal_range = _swig_new_instance_method(_pyBasePython.setUL_equal_range)
    insert = _swig_new_instance_method(_pyBasePython.setUL_insert)
    __swig_destroy__ = _pyBasePython.delete_setUL

# Register setUL in _pyBasePython:
_pyBasePython.setUL_swigregister(setUL)
class setULL(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.setULL_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.setULL___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.setULL___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.setULL___len__)
    append = _swig_new_instance_method(_pyBasePython.setULL_append)
    __contains__ = _swig_new_instance_method(_pyBasePython.setULL___contains__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.setULL___getitem__)
    add = _swig_new_instance_method(_pyBasePython.setULL_add)
    discard = _swig_new_instance_method(_pyBasePython.setULL_discard)

    def __init__(self, *args):
        r"""
        __init__(setULL self, std::less< unsigned long long > const & other) -> setULL
        __init__(setULL self) -> setULL
        __init__(setULL self, setULL other) -> setULL
        """
        _pyBasePython.setULL_swiginit(self, _pyBasePython.new_setULL(*args))
    empty = _swig_new_instance_method(_pyBasePython.setULL_empty)
    size = _swig_new_instance_method(_pyBasePython.setULL_size)
    clear = _swig_new_instance_method(_pyBasePython.setULL_clear)
    swap = _swig_new_instance_method(_pyBasePython.setULL_swap)
    count = _swig_new_instance_method(_pyBasePython.setULL_count)
    begin = _swig_new_instance_method(_pyBasePython.setULL_begin)
    end = _swig_new_instance_method(_pyBasePython.setULL_end)
    rbegin = _swig_new_instance_method(_pyBasePython.setULL_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.setULL_rend)
    erase = _swig_new_instance_method(_pyBasePython.setULL_erase)
    find = _swig_new_instance_method(_pyBasePython.setULL_find)
    lower_bound = _swig_new_instance_method(_pyBasePython.setULL_lower_bound)
    upper_bound = _swig_new_instance_method(_pyBasePython.setULL_upper_bound)
    equal_range = _swig_new_instance_method(_pyBasePython.setULL_equal_range)
    insert = _swig_new_instance_method(_pyBasePython.setULL_insert)
    __swig_destroy__ = _pyBasePython.delete_setULL

# Register setULL in _pyBasePython:
_pyBasePython.setULL_swigregister(setULL)
class setSC(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.setSC_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.setSC___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.setSC___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.setSC___len__)
    append = _swig_new_instance_method(_pyBasePython.setSC_append)
    __contains__ = _swig_new_instance_method(_pyBasePython.setSC___contains__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.setSC___getitem__)
    add = _swig_new_instance_method(_pyBasePython.setSC_add)
    discard = _swig_new_instance_method(_pyBasePython.setSC_discard)

    def __init__(self, *args):
        r"""
        __init__(setSC self, std::less< signed char > const & other) -> setSC
        __init__(setSC self) -> setSC
        __init__(setSC self, setSC other) -> setSC
        """
        _pyBasePython.setSC_swiginit(self, _pyBasePython.new_setSC(*args))
    empty = _swig_new_instance_method(_pyBasePython.setSC_empty)
    size = _swig_new_instance_method(_pyBasePython.setSC_size)
    clear = _swig_new_instance_method(_pyBasePython.setSC_clear)
    swap = _swig_new_instance_method(_pyBasePython.setSC_swap)
    count = _swig_new_instance_method(_pyBasePython.setSC_count)
    begin = _swig_new_instance_method(_pyBasePython.setSC_begin)
    end = _swig_new_instance_method(_pyBasePython.setSC_end)
    rbegin = _swig_new_instance_method(_pyBasePython.setSC_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.setSC_rend)
    erase = _swig_new_instance_method(_pyBasePython.setSC_erase)
    find = _swig_new_instance_method(_pyBasePython.setSC_find)
    lower_bound = _swig_new_instance_method(_pyBasePython.setSC_lower_bound)
    upper_bound = _swig_new_instance_method(_pyBasePython.setSC_upper_bound)
    equal_range = _swig_new_instance_method(_pyBasePython.setSC_equal_range)
    insert = _swig_new_instance_method(_pyBasePython.setSC_insert)
    __swig_destroy__ = _pyBasePython.delete_setSC

# Register setSC in _pyBasePython:
_pyBasePython.setSC_swigregister(setSC)
class setSS(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.setSS_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.setSS___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.setSS___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.setSS___len__)
    append = _swig_new_instance_method(_pyBasePython.setSS_append)
    __contains__ = _swig_new_instance_method(_pyBasePython.setSS___contains__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.setSS___getitem__)
    add = _swig_new_instance_method(_pyBasePython.setSS_add)
    discard = _swig_new_instance_method(_pyBasePython.setSS_discard)

    def __init__(self, *args):
        r"""
        __init__(setSS self, std::less< short > const & other) -> setSS
        __init__(setSS self) -> setSS
        __init__(setSS self, setSS other) -> setSS
        """
        _pyBasePython.setSS_swiginit(self, _pyBasePython.new_setSS(*args))
    empty = _swig_new_instance_method(_pyBasePython.setSS_empty)
    size = _swig_new_instance_method(_pyBasePython.setSS_size)
    clear = _swig_new_instance_method(_pyBasePython.setSS_clear)
    swap = _swig_new_instance_method(_pyBasePython.setSS_swap)
    count = _swig_new_instance_method(_pyBasePython.setSS_count)
    begin = _swig_new_instance_method(_pyBasePython.setSS_begin)
    end = _swig_new_instance_method(_pyBasePython.setSS_end)
    rbegin = _swig_new_instance_method(_pyBasePython.setSS_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.setSS_rend)
    erase = _swig_new_instance_method(_pyBasePython.setSS_erase)
    find = _swig_new_instance_method(_pyBasePython.setSS_find)
    lower_bound = _swig_new_instance_method(_pyBasePython.setSS_lower_bound)
    upper_bound = _swig_new_instance_method(_pyBasePython.setSS_upper_bound)
    equal_range = _swig_new_instance_method(_pyBasePython.setSS_equal_range)
    insert = _swig_new_instance_method(_pyBasePython.setSS_insert)
    __swig_destroy__ = _pyBasePython.delete_setSS

# Register setSS in _pyBasePython:
_pyBasePython.setSS_swigregister(setSS)
class setSL(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.setSL_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.setSL___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.setSL___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.setSL___len__)
    append = _swig_new_instance_method(_pyBasePython.setSL_append)
    __contains__ = _swig_new_instance_method(_pyBasePython.setSL___contains__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.setSL___getitem__)
    add = _swig_new_instance_method(_pyBasePython.setSL_add)
    discard = _swig_new_instance_method(_pyBasePython.setSL_discard)

    def __init__(self, *args):
        r"""
        __init__(setSL self, std::less< long > const & other) -> setSL
        __init__(setSL self) -> setSL
        __init__(setSL self, setSL other) -> setSL
        """
        _pyBasePython.setSL_swiginit(self, _pyBasePython.new_setSL(*args))
    empty = _swig_new_instance_method(_pyBasePython.setSL_empty)
    size = _swig_new_instance_method(_pyBasePython.setSL_size)
    clear = _swig_new_instance_method(_pyBasePython.setSL_clear)
    swap = _swig_new_instance_method(_pyBasePython.setSL_swap)
    count = _swig_new_instance_method(_pyBasePython.setSL_count)
    begin = _swig_new_instance_method(_pyBasePython.setSL_begin)
    end = _swig_new_instance_method(_pyBasePython.setSL_end)
    rbegin = _swig_new_instance_method(_pyBasePython.setSL_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.setSL_rend)
    erase = _swig_new_instance_method(_pyBasePython.setSL_erase)
    find = _swig_new_instance_method(_pyBasePython.setSL_find)
    lower_bound = _swig_new_instance_method(_pyBasePython.setSL_lower_bound)
    upper_bound = _swig_new_instance_method(_pyBasePython.setSL_upper_bound)
    equal_range = _swig_new_instance_method(_pyBasePython.setSL_equal_range)
    insert = _swig_new_instance_method(_pyBasePython.setSL_insert)
    __swig_destroy__ = _pyBasePython.delete_setSL

# Register setSL in _pyBasePython:
_pyBasePython.setSL_swigregister(setSL)
class setSLL(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.setSLL_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.setSLL___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.setSLL___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.setSLL___len__)
    append = _swig_new_instance_method(_pyBasePython.setSLL_append)
    __contains__ = _swig_new_instance_method(_pyBasePython.setSLL___contains__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.setSLL___getitem__)
    add = _swig_new_instance_method(_pyBasePython.setSLL_add)
    discard = _swig_new_instance_method(_pyBasePython.setSLL_discard)

    def __init__(self, *args):
        r"""
        __init__(setSLL self, std::less< long long > const & other) -> setSLL
        __init__(setSLL self) -> setSLL
        __init__(setSLL self, setSLL other) -> setSLL
        """
        _pyBasePython.setSLL_swiginit(self, _pyBasePython.new_setSLL(*args))
    empty = _swig_new_instance_method(_pyBasePython.setSLL_empty)
    size = _swig_new_instance_method(_pyBasePython.setSLL_size)
    clear = _swig_new_instance_method(_pyBasePython.setSLL_clear)
    swap = _swig_new_instance_method(_pyBasePython.setSLL_swap)
    count = _swig_new_instance_method(_pyBasePython.setSLL_count)
    begin = _swig_new_instance_method(_pyBasePython.setSLL_begin)
    end = _swig_new_instance_method(_pyBasePython.setSLL_end)
    rbegin = _swig_new_instance_method(_pyBasePython.setSLL_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.setSLL_rend)
    erase = _swig_new_instance_method(_pyBasePython.setSLL_erase)
    find = _swig_new_instance_method(_pyBasePython.setSLL_find)
    lower_bound = _swig_new_instance_method(_pyBasePython.setSLL_lower_bound)
    upper_bound = _swig_new_instance_method(_pyBasePython.setSLL_upper_bound)
    equal_range = _swig_new_instance_method(_pyBasePython.setSLL_equal_range)
    insert = _swig_new_instance_method(_pyBasePython.setSLL_insert)
    __swig_destroy__ = _pyBasePython.delete_setSLL

# Register setSLL in _pyBasePython:
_pyBasePython.setSLL_swigregister(setSLL)
class setF(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.setF_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.setF___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.setF___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.setF___len__)
    append = _swig_new_instance_method(_pyBasePython.setF_append)
    __contains__ = _swig_new_instance_method(_pyBasePython.setF___contains__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.setF___getitem__)
    add = _swig_new_instance_method(_pyBasePython.setF_add)
    discard = _swig_new_instance_method(_pyBasePython.setF_discard)

    def __init__(self, *args):
        r"""
        __init__(setF self, std::less< float > const & other) -> setF
        __init__(setF self) -> setF
        __init__(setF self, setF other) -> setF
        """
        _pyBasePython.setF_swiginit(self, _pyBasePython.new_setF(*args))
    empty = _swig_new_instance_method(_pyBasePython.setF_empty)
    size = _swig_new_instance_method(_pyBasePython.setF_size)
    clear = _swig_new_instance_method(_pyBasePython.setF_clear)
    swap = _swig_new_instance_method(_pyBasePython.setF_swap)
    count = _swig_new_instance_method(_pyBasePython.setF_count)
    begin = _swig_new_instance_method(_pyBasePython.setF_begin)
    end = _swig_new_instance_method(_pyBasePython.setF_end)
    rbegin = _swig_new_instance_method(_pyBasePython.setF_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.setF_rend)
    erase = _swig_new_instance_method(_pyBasePython.setF_erase)
    find = _swig_new_instance_method(_pyBasePython.setF_find)
    lower_bound = _swig_new_instance_method(_pyBasePython.setF_lower_bound)
    upper_bound = _swig_new_instance_method(_pyBasePython.setF_upper_bound)
    equal_range = _swig_new_instance_method(_pyBasePython.setF_equal_range)
    insert = _swig_new_instance_method(_pyBasePython.setF_insert)
    __swig_destroy__ = _pyBasePython.delete_setF

# Register setF in _pyBasePython:
_pyBasePython.setF_swigregister(setF)
class setD(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.setD_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.setD___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.setD___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.setD___len__)
    append = _swig_new_instance_method(_pyBasePython.setD_append)
    __contains__ = _swig_new_instance_method(_pyBasePython.setD___contains__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.setD___getitem__)
    add = _swig_new_instance_method(_pyBasePython.setD_add)
    discard = _swig_new_instance_method(_pyBasePython.setD_discard)

    def __init__(self, *args):
        r"""
        __init__(setD self, std::less< double > const & other) -> setD
        __init__(setD self) -> setD
        __init__(setD self, setD other) -> setD
        """
        _pyBasePython.setD_swiginit(self, _pyBasePython.new_setD(*args))
    empty = _swig_new_instance_method(_pyBasePython.setD_empty)
    size = _swig_new_instance_method(_pyBasePython.setD_size)
    clear = _swig_new_instance_method(_pyBasePython.setD_clear)
    swap = _swig_new_instance_method(_pyBasePython.setD_swap)
    count = _swig_new_instance_method(_pyBasePython.setD_count)
    begin = _swig_new_instance_method(_pyBasePython.setD_begin)
    end = _swig_new_instance_method(_pyBasePython.setD_end)
    rbegin = _swig_new_instance_method(_pyBasePython.setD_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.setD_rend)
    erase = _swig_new_instance_method(_pyBasePython.setD_erase)
    find = _swig_new_instance_method(_pyBasePython.setD_find)
    lower_bound = _swig_new_instance_method(_pyBasePython.setD_lower_bound)
    upper_bound = _swig_new_instance_method(_pyBasePython.setD_upper_bound)
    equal_range = _swig_new_instance_method(_pyBasePython.setD_equal_range)
    insert = _swig_new_instance_method(_pyBasePython.setD_insert)
    __swig_destroy__ = _pyBasePython.delete_setD

# Register setD in _pyBasePython:
_pyBasePython.setD_swigregister(setD)
class vectorsetUL(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.vectorsetUL_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.vectorsetUL___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.vectorsetUL___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.vectorsetUL___len__)
    __getslice__ = _swig_new_instance_method(_pyBasePython.vectorsetUL___getslice__)
    __setslice__ = _swig_new_instance_method(_pyBasePython.vectorsetUL___setslice__)
    __delslice__ = _swig_new_instance_method(_pyBasePython.vectorsetUL___delslice__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.vectorsetUL___delitem__)
    __getitem__ = _swig_new_instance_method(_pyBasePython.vectorsetUL___getitem__)
    __setitem__ = _swig_new_instance_method(_pyBasePython.vectorsetUL___setitem__)
    pop = _swig_new_instance_method(_pyBasePython.vectorsetUL_pop)
    append = _swig_new_instance_method(_pyBasePython.vectorsetUL_append)
    empty = _swig_new_instance_method(_pyBasePython.vectorsetUL_empty)
    size = _swig_new_instance_method(_pyBasePython.vectorsetUL_size)
    swap = _swig_new_instance_method(_pyBasePython.vectorsetUL_swap)
    begin = _swig_new_instance_method(_pyBasePython.vectorsetUL_begin)
    end = _swig_new_instance_method(_pyBasePython.vectorsetUL_end)
    rbegin = _swig_new_instance_method(_pyBasePython.vectorsetUL_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.vectorsetUL_rend)
    clear = _swig_new_instance_method(_pyBasePython.vectorsetUL_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.vectorsetUL_get_allocator)
    pop_back = _swig_new_instance_method(_pyBasePython.vectorsetUL_pop_back)
    erase = _swig_new_instance_method(_pyBasePython.vectorsetUL_erase)

    def __init__(self, *args):
        r"""
        __init__(vectorsetUL self) -> vectorsetUL
        __init__(vectorsetUL self, vectorsetUL other) -> vectorsetUL
        __init__(vectorsetUL self, std::vector< std::set< unsigned long,std::less< unsigned long > > >::size_type size) -> vectorsetUL
        __init__(vectorsetUL self, std::vector< std::set< unsigned long,std::less< unsigned long > > >::size_type size, setUL value) -> vectorsetUL
        """
        _pyBasePython.vectorsetUL_swiginit(self, _pyBasePython.new_vectorsetUL(*args))
    push_back = _swig_new_instance_method(_pyBasePython.vectorsetUL_push_back)
    front = _swig_new_instance_method(_pyBasePython.vectorsetUL_front)
    back = _swig_new_instance_method(_pyBasePython.vectorsetUL_back)
    assign = _swig_new_instance_method(_pyBasePython.vectorsetUL_assign)
    resize = _swig_new_instance_method(_pyBasePython.vectorsetUL_resize)
    insert = _swig_new_instance_method(_pyBasePython.vectorsetUL_insert)
    reserve = _swig_new_instance_method(_pyBasePython.vectorsetUL_reserve)
    capacity = _swig_new_instance_method(_pyBasePython.vectorsetUL_capacity)
    __swig_destroy__ = _pyBasePython.delete_vectorsetUL

# Register vectorsetUL in _pyBasePython:
_pyBasePython.vectorsetUL_swigregister(vectorsetUL)
class mapsetUL(object):
    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
    iterator = _swig_new_instance_method(_pyBasePython.mapsetUL_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_pyBasePython.mapsetUL___nonzero__)
    __bool__ = _swig_new_instance_method(_pyBasePython.mapsetUL___bool__)
    __len__ = _swig_new_instance_method(_pyBasePython.mapsetUL___len__)
    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()
    __getitem__ = _swig_new_instance_method(_pyBasePython.mapsetUL___getitem__)
    __delitem__ = _swig_new_instance_method(_pyBasePython.mapsetUL___delitem__)
    has_key = _swig_new_instance_method(_pyBasePython.mapsetUL_has_key)
    keys = _swig_new_instance_method(_pyBasePython.mapsetUL_keys)
    values = _swig_new_instance_method(_pyBasePython.mapsetUL_values)
    items = _swig_new_instance_method(_pyBasePython.mapsetUL_items)
    __contains__ = _swig_new_instance_method(_pyBasePython.mapsetUL___contains__)
    key_iterator = _swig_new_instance_method(_pyBasePython.mapsetUL_key_iterator)
    value_iterator = _swig_new_instance_method(_pyBasePython.mapsetUL_value_iterator)
    __setitem__ = _swig_new_instance_method(_pyBasePython.mapsetUL___setitem__)
    asdict = _swig_new_instance_method(_pyBasePython.mapsetUL_asdict)

    def __init__(self, *args):
        r"""
        __init__(mapsetUL self, std::less< unsigned long > const & other) -> mapsetUL
        __init__(mapsetUL self) -> mapsetUL
        __init__(mapsetUL self, mapsetUL other) -> mapsetUL
        """
        _pyBasePython.mapsetUL_swiginit(self, _pyBasePython.new_mapsetUL(*args))
    empty = _swig_new_instance_method(_pyBasePython.mapsetUL_empty)
    size = _swig_new_instance_method(_pyBasePython.mapsetUL_size)
    swap = _swig_new_instance_method(_pyBasePython.mapsetUL_swap)
    begin = _swig_new_instance_method(_pyBasePython.mapsetUL_begin)
    end = _swig_new_instance_method(_pyBasePython.mapsetUL_end)
    rbegin = _swig_new_instance_method(_pyBasePython.mapsetUL_rbegin)
    rend = _swig_new_instance_method(_pyBasePython.mapsetUL_rend)
    clear = _swig_new_instance_method(_pyBasePython.mapsetUL_clear)
    get_allocator = _swig_new_instance_method(_pyBasePython.mapsetUL_get_allocator)
    count = _swig_new_instance_method(_pyBasePython.mapsetUL_count)
    erase = _swig_new_instance_method(_pyBasePython.mapsetUL_erase)
    find = _swig_new_instance_method(_pyBasePython.mapsetUL_find)
    lower_bound = _swig_new_instance_method(_pyBasePython.mapsetUL_lower_bound)
    upper_bound = _swig_new_instance_method(_pyBasePython.mapsetUL_upper_bound)
    __swig_destroy__ = _pyBasePython.delete_mapsetUL

# Register mapsetUL in _pyBasePython:
_pyBasePython.mapsetUL_swigregister(mapsetUL)

