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

from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_pysz')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_pysz')
    _pysz = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_pysz', [dirname(__file__)])
        except ImportError:
            import _pysz
            return _pysz
        try:
            _mod = imp.load_module('_pysz', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _pysz = swig_import_helper()
    del swig_import_helper
else:
    import _pysz
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0

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

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)

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

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


    def __sub__(self, *args):
        """
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
        """
        return _pysz.SwigPyIterator___sub__(self, *args)

    def __iter__(self):
        return self
SwigPyIterator_swigregister = _pysz.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class vectori8(_object):
    """Proxy of C++ std::vector<(int8_t)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vectori8, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vectori8, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(vectori8 self) -> SwigPyIterator"""
        return _pysz.vectori8_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(vectori8 self) -> bool"""
        return _pysz.vectori8___nonzero__(self)


    def __bool__(self):
        """__bool__(vectori8 self) -> bool"""
        return _pysz.vectori8___bool__(self)


    def __len__(self):
        """__len__(vectori8 self) -> std::vector< int8_t >::size_type"""
        return _pysz.vectori8___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(vectori8 self, std::vector< int8_t >::difference_type i, std::vector< int8_t >::difference_type j) -> vectori8"""
        return _pysz.vectori8___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(vectori8 self, std::vector< int8_t >::difference_type i, std::vector< int8_t >::difference_type j)
        __setslice__(vectori8 self, std::vector< int8_t >::difference_type i, std::vector< int8_t >::difference_type j, vectori8 v)
        """
        return _pysz.vectori8___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(vectori8 self, std::vector< int8_t >::difference_type i, std::vector< int8_t >::difference_type j)"""
        return _pysz.vectori8___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(vectori8 self, std::vector< int8_t >::difference_type i)
        __delitem__(vectori8 self, PySliceObject * slice)
        """
        return _pysz.vectori8___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(vectori8 self, PySliceObject * slice) -> vectori8
        __getitem__(vectori8 self, std::vector< int8_t >::difference_type i) -> std::vector< int8_t >::value_type const &
        """
        return _pysz.vectori8___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(vectori8 self, PySliceObject * slice, vectori8 v)
        __setitem__(vectori8 self, PySliceObject * slice)
        __setitem__(vectori8 self, std::vector< int8_t >::difference_type i, std::vector< int8_t >::value_type const & x)
        """
        return _pysz.vectori8___setitem__(self, *args)


    def pop(self):
        """pop(vectori8 self) -> std::vector< int8_t >::value_type"""
        return _pysz.vectori8_pop(self)


    def append(self, x):
        """append(vectori8 self, std::vector< int8_t >::value_type const & x)"""
        return _pysz.vectori8_append(self, x)


    def empty(self):
        """empty(vectori8 self) -> bool"""
        return _pysz.vectori8_empty(self)


    def size(self):
        """size(vectori8 self) -> std::vector< int8_t >::size_type"""
        return _pysz.vectori8_size(self)


    def swap(self, v):
        """swap(vectori8 self, vectori8 v)"""
        return _pysz.vectori8_swap(self, v)


    def begin(self):
        """begin(vectori8 self) -> std::vector< int8_t >::iterator"""
        return _pysz.vectori8_begin(self)


    def end(self):
        """end(vectori8 self) -> std::vector< int8_t >::iterator"""
        return _pysz.vectori8_end(self)


    def rbegin(self):
        """rbegin(vectori8 self) -> std::vector< int8_t >::reverse_iterator"""
        return _pysz.vectori8_rbegin(self)


    def rend(self):
        """rend(vectori8 self) -> std::vector< int8_t >::reverse_iterator"""
        return _pysz.vectori8_rend(self)


    def clear(self):
        """clear(vectori8 self)"""
        return _pysz.vectori8_clear(self)


    def get_allocator(self):
        """get_allocator(vectori8 self) -> std::vector< int8_t >::allocator_type"""
        return _pysz.vectori8_get_allocator(self)


    def pop_back(self):
        """pop_back(vectori8 self)"""
        return _pysz.vectori8_pop_back(self)


    def erase(self, *args):
        """
        erase(vectori8 self, std::vector< int8_t >::iterator pos) -> std::vector< int8_t >::iterator
        erase(vectori8 self, std::vector< int8_t >::iterator first, std::vector< int8_t >::iterator last) -> std::vector< int8_t >::iterator
        """
        return _pysz.vectori8_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(int8_t)> self) -> vectori8
        __init__(std::vector<(int8_t)> self, vectori8 arg2) -> vectori8
        __init__(std::vector<(int8_t)> self, std::vector< int8_t >::size_type size) -> vectori8
        __init__(std::vector<(int8_t)> self, std::vector< int8_t >::size_type size, std::vector< int8_t >::value_type const & value) -> vectori8
        """
        this = _pysz.new_vectori8(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(vectori8 self, std::vector< int8_t >::value_type const & x)"""
        return _pysz.vectori8_push_back(self, x)


    def front(self):
        """front(vectori8 self) -> std::vector< int8_t >::value_type const &"""
        return _pysz.vectori8_front(self)


    def back(self):
        """back(vectori8 self) -> std::vector< int8_t >::value_type const &"""
        return _pysz.vectori8_back(self)


    def assign(self, n, x):
        """assign(vectori8 self, std::vector< int8_t >::size_type n, std::vector< int8_t >::value_type const & x)"""
        return _pysz.vectori8_assign(self, n, x)


    def resize(self, *args):
        """
        resize(vectori8 self, std::vector< int8_t >::size_type new_size)
        resize(vectori8 self, std::vector< int8_t >::size_type new_size, std::vector< int8_t >::value_type const & x)
        """
        return _pysz.vectori8_resize(self, *args)


    def insert(self, *args):
        """
        insert(vectori8 self, std::vector< int8_t >::iterator pos, std::vector< int8_t >::value_type const & x) -> std::vector< int8_t >::iterator
        insert(vectori8 self, std::vector< int8_t >::iterator pos, std::vector< int8_t >::size_type n, std::vector< int8_t >::value_type const & x)
        """
        return _pysz.vectori8_insert(self, *args)


    def reserve(self, n):
        """reserve(vectori8 self, std::vector< int8_t >::size_type n)"""
        return _pysz.vectori8_reserve(self, n)


    def capacity(self):
        """capacity(vectori8 self) -> std::vector< int8_t >::size_type"""
        return _pysz.vectori8_capacity(self)

    __swig_destroy__ = _pysz.delete_vectori8
    __del__ = lambda self: None
vectori8_swigregister = _pysz.vectori8_swigregister
vectori8_swigregister(vectori8)

class vectori16(_object):
    """Proxy of C++ std::vector<(int16_t)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vectori16, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vectori16, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(vectori16 self) -> SwigPyIterator"""
        return _pysz.vectori16_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(vectori16 self) -> bool"""
        return _pysz.vectori16___nonzero__(self)


    def __bool__(self):
        """__bool__(vectori16 self) -> bool"""
        return _pysz.vectori16___bool__(self)


    def __len__(self):
        """__len__(vectori16 self) -> std::vector< int16_t >::size_type"""
        return _pysz.vectori16___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(vectori16 self, std::vector< int16_t >::difference_type i, std::vector< int16_t >::difference_type j) -> vectori16"""
        return _pysz.vectori16___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(vectori16 self, std::vector< int16_t >::difference_type i, std::vector< int16_t >::difference_type j)
        __setslice__(vectori16 self, std::vector< int16_t >::difference_type i, std::vector< int16_t >::difference_type j, vectori16 v)
        """
        return _pysz.vectori16___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(vectori16 self, std::vector< int16_t >::difference_type i, std::vector< int16_t >::difference_type j)"""
        return _pysz.vectori16___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(vectori16 self, std::vector< int16_t >::difference_type i)
        __delitem__(vectori16 self, PySliceObject * slice)
        """
        return _pysz.vectori16___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(vectori16 self, PySliceObject * slice) -> vectori16
        __getitem__(vectori16 self, std::vector< int16_t >::difference_type i) -> std::vector< int16_t >::value_type const &
        """
        return _pysz.vectori16___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(vectori16 self, PySliceObject * slice, vectori16 v)
        __setitem__(vectori16 self, PySliceObject * slice)
        __setitem__(vectori16 self, std::vector< int16_t >::difference_type i, std::vector< int16_t >::value_type const & x)
        """
        return _pysz.vectori16___setitem__(self, *args)


    def pop(self):
        """pop(vectori16 self) -> std::vector< int16_t >::value_type"""
        return _pysz.vectori16_pop(self)


    def append(self, x):
        """append(vectori16 self, std::vector< int16_t >::value_type const & x)"""
        return _pysz.vectori16_append(self, x)


    def empty(self):
        """empty(vectori16 self) -> bool"""
        return _pysz.vectori16_empty(self)


    def size(self):
        """size(vectori16 self) -> std::vector< int16_t >::size_type"""
        return _pysz.vectori16_size(self)


    def swap(self, v):
        """swap(vectori16 self, vectori16 v)"""
        return _pysz.vectori16_swap(self, v)


    def begin(self):
        """begin(vectori16 self) -> std::vector< int16_t >::iterator"""
        return _pysz.vectori16_begin(self)


    def end(self):
        """end(vectori16 self) -> std::vector< int16_t >::iterator"""
        return _pysz.vectori16_end(self)


    def rbegin(self):
        """rbegin(vectori16 self) -> std::vector< int16_t >::reverse_iterator"""
        return _pysz.vectori16_rbegin(self)


    def rend(self):
        """rend(vectori16 self) -> std::vector< int16_t >::reverse_iterator"""
        return _pysz.vectori16_rend(self)


    def clear(self):
        """clear(vectori16 self)"""
        return _pysz.vectori16_clear(self)


    def get_allocator(self):
        """get_allocator(vectori16 self) -> std::vector< int16_t >::allocator_type"""
        return _pysz.vectori16_get_allocator(self)


    def pop_back(self):
        """pop_back(vectori16 self)"""
        return _pysz.vectori16_pop_back(self)


    def erase(self, *args):
        """
        erase(vectori16 self, std::vector< int16_t >::iterator pos) -> std::vector< int16_t >::iterator
        erase(vectori16 self, std::vector< int16_t >::iterator first, std::vector< int16_t >::iterator last) -> std::vector< int16_t >::iterator
        """
        return _pysz.vectori16_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(int16_t)> self) -> vectori16
        __init__(std::vector<(int16_t)> self, vectori16 arg2) -> vectori16
        __init__(std::vector<(int16_t)> self, std::vector< int16_t >::size_type size) -> vectori16
        __init__(std::vector<(int16_t)> self, std::vector< int16_t >::size_type size, std::vector< int16_t >::value_type const & value) -> vectori16
        """
        this = _pysz.new_vectori16(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(vectori16 self, std::vector< int16_t >::value_type const & x)"""
        return _pysz.vectori16_push_back(self, x)


    def front(self):
        """front(vectori16 self) -> std::vector< int16_t >::value_type const &"""
        return _pysz.vectori16_front(self)


    def back(self):
        """back(vectori16 self) -> std::vector< int16_t >::value_type const &"""
        return _pysz.vectori16_back(self)


    def assign(self, n, x):
        """assign(vectori16 self, std::vector< int16_t >::size_type n, std::vector< int16_t >::value_type const & x)"""
        return _pysz.vectori16_assign(self, n, x)


    def resize(self, *args):
        """
        resize(vectori16 self, std::vector< int16_t >::size_type new_size)
        resize(vectori16 self, std::vector< int16_t >::size_type new_size, std::vector< int16_t >::value_type const & x)
        """
        return _pysz.vectori16_resize(self, *args)


    def insert(self, *args):
        """
        insert(vectori16 self, std::vector< int16_t >::iterator pos, std::vector< int16_t >::value_type const & x) -> std::vector< int16_t >::iterator
        insert(vectori16 self, std::vector< int16_t >::iterator pos, std::vector< int16_t >::size_type n, std::vector< int16_t >::value_type const & x)
        """
        return _pysz.vectori16_insert(self, *args)


    def reserve(self, n):
        """reserve(vectori16 self, std::vector< int16_t >::size_type n)"""
        return _pysz.vectori16_reserve(self, n)


    def capacity(self):
        """capacity(vectori16 self) -> std::vector< int16_t >::size_type"""
        return _pysz.vectori16_capacity(self)

    __swig_destroy__ = _pysz.delete_vectori16
    __del__ = lambda self: None
vectori16_swigregister = _pysz.vectori16_swigregister
vectori16_swigregister(vectori16)

class vectori32(_object):
    """Proxy of C++ std::vector<(int)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vectori32, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vectori32, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(vectori32 self) -> SwigPyIterator"""
        return _pysz.vectori32_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(vectori32 self) -> bool"""
        return _pysz.vectori32___nonzero__(self)


    def __bool__(self):
        """__bool__(vectori32 self) -> bool"""
        return _pysz.vectori32___bool__(self)


    def __len__(self):
        """__len__(vectori32 self) -> std::vector< int >::size_type"""
        return _pysz.vectori32___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(vectori32 self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> vectori32"""
        return _pysz.vectori32___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(vectori32 self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)
        __setslice__(vectori32 self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, vectori32 v)
        """
        return _pysz.vectori32___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(vectori32 self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"""
        return _pysz.vectori32___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(vectori32 self, std::vector< int >::difference_type i)
        __delitem__(vectori32 self, PySliceObject * slice)
        """
        return _pysz.vectori32___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(vectori32 self, PySliceObject * slice) -> vectori32
        __getitem__(vectori32 self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &
        """
        return _pysz.vectori32___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(vectori32 self, PySliceObject * slice, vectori32 v)
        __setitem__(vectori32 self, PySliceObject * slice)
        __setitem__(vectori32 self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)
        """
        return _pysz.vectori32___setitem__(self, *args)


    def pop(self):
        """pop(vectori32 self) -> std::vector< int >::value_type"""
        return _pysz.vectori32_pop(self)


    def append(self, x):
        """append(vectori32 self, std::vector< int >::value_type const & x)"""
        return _pysz.vectori32_append(self, x)


    def empty(self):
        """empty(vectori32 self) -> bool"""
        return _pysz.vectori32_empty(self)


    def size(self):
        """size(vectori32 self) -> std::vector< int >::size_type"""
        return _pysz.vectori32_size(self)


    def swap(self, v):
        """swap(vectori32 self, vectori32 v)"""
        return _pysz.vectori32_swap(self, v)


    def begin(self):
        """begin(vectori32 self) -> std::vector< int >::iterator"""
        return _pysz.vectori32_begin(self)


    def end(self):
        """end(vectori32 self) -> std::vector< int >::iterator"""
        return _pysz.vectori32_end(self)


    def rbegin(self):
        """rbegin(vectori32 self) -> std::vector< int >::reverse_iterator"""
        return _pysz.vectori32_rbegin(self)


    def rend(self):
        """rend(vectori32 self) -> std::vector< int >::reverse_iterator"""
        return _pysz.vectori32_rend(self)


    def clear(self):
        """clear(vectori32 self)"""
        return _pysz.vectori32_clear(self)


    def get_allocator(self):
        """get_allocator(vectori32 self) -> std::vector< int >::allocator_type"""
        return _pysz.vectori32_get_allocator(self)


    def pop_back(self):
        """pop_back(vectori32 self)"""
        return _pysz.vectori32_pop_back(self)


    def erase(self, *args):
        """
        erase(vectori32 self, std::vector< int >::iterator pos) -> std::vector< int >::iterator
        erase(vectori32 self, std::vector< int >::iterator first, std::vector< int >::iterator last) -> std::vector< int >::iterator
        """
        return _pysz.vectori32_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(int)> self) -> vectori32
        __init__(std::vector<(int)> self, vectori32 arg2) -> vectori32
        __init__(std::vector<(int)> self, std::vector< int >::size_type size) -> vectori32
        __init__(std::vector<(int)> self, std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> vectori32
        """
        this = _pysz.new_vectori32(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(vectori32 self, std::vector< int >::value_type const & x)"""
        return _pysz.vectori32_push_back(self, x)


    def front(self):
        """front(vectori32 self) -> std::vector< int >::value_type const &"""
        return _pysz.vectori32_front(self)


    def back(self):
        """back(vectori32 self) -> std::vector< int >::value_type const &"""
        return _pysz.vectori32_back(self)


    def assign(self, n, x):
        """assign(vectori32 self, std::vector< int >::size_type n, std::vector< int >::value_type const & x)"""
        return _pysz.vectori32_assign(self, n, x)


    def resize(self, *args):
        """
        resize(vectori32 self, std::vector< int >::size_type new_size)
        resize(vectori32 self, std::vector< int >::size_type new_size, std::vector< int >::value_type const & x)
        """
        return _pysz.vectori32_resize(self, *args)


    def insert(self, *args):
        """
        insert(vectori32 self, std::vector< int >::iterator pos, std::vector< int >::value_type const & x) -> std::vector< int >::iterator
        insert(vectori32 self, std::vector< int >::iterator pos, std::vector< int >::size_type n, std::vector< int >::value_type const & x)
        """
        return _pysz.vectori32_insert(self, *args)


    def reserve(self, n):
        """reserve(vectori32 self, std::vector< int >::size_type n)"""
        return _pysz.vectori32_reserve(self, n)


    def capacity(self):
        """capacity(vectori32 self) -> std::vector< int >::size_type"""
        return _pysz.vectori32_capacity(self)

    __swig_destroy__ = _pysz.delete_vectori32
    __del__ = lambda self: None
vectori32_swigregister = _pysz.vectori32_swigregister
vectori32_swigregister(vectori32)

class vectori64(_object):
    """Proxy of C++ std::vector<(int64_t)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vectori64, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vectori64, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(vectori64 self) -> SwigPyIterator"""
        return _pysz.vectori64_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(vectori64 self) -> bool"""
        return _pysz.vectori64___nonzero__(self)


    def __bool__(self):
        """__bool__(vectori64 self) -> bool"""
        return _pysz.vectori64___bool__(self)


    def __len__(self):
        """__len__(vectori64 self) -> std::vector< int64_t >::size_type"""
        return _pysz.vectori64___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(vectori64 self, std::vector< int64_t >::difference_type i, std::vector< int64_t >::difference_type j) -> vectori64"""
        return _pysz.vectori64___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(vectori64 self, std::vector< int64_t >::difference_type i, std::vector< int64_t >::difference_type j)
        __setslice__(vectori64 self, std::vector< int64_t >::difference_type i, std::vector< int64_t >::difference_type j, vectori64 v)
        """
        return _pysz.vectori64___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(vectori64 self, std::vector< int64_t >::difference_type i, std::vector< int64_t >::difference_type j)"""
        return _pysz.vectori64___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(vectori64 self, std::vector< int64_t >::difference_type i)
        __delitem__(vectori64 self, PySliceObject * slice)
        """
        return _pysz.vectori64___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(vectori64 self, PySliceObject * slice) -> vectori64
        __getitem__(vectori64 self, std::vector< int64_t >::difference_type i) -> std::vector< int64_t >::value_type const &
        """
        return _pysz.vectori64___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(vectori64 self, PySliceObject * slice, vectori64 v)
        __setitem__(vectori64 self, PySliceObject * slice)
        __setitem__(vectori64 self, std::vector< int64_t >::difference_type i, std::vector< int64_t >::value_type const & x)
        """
        return _pysz.vectori64___setitem__(self, *args)


    def pop(self):
        """pop(vectori64 self) -> std::vector< int64_t >::value_type"""
        return _pysz.vectori64_pop(self)


    def append(self, x):
        """append(vectori64 self, std::vector< int64_t >::value_type const & x)"""
        return _pysz.vectori64_append(self, x)


    def empty(self):
        """empty(vectori64 self) -> bool"""
        return _pysz.vectori64_empty(self)


    def size(self):
        """size(vectori64 self) -> std::vector< int64_t >::size_type"""
        return _pysz.vectori64_size(self)


    def swap(self, v):
        """swap(vectori64 self, vectori64 v)"""
        return _pysz.vectori64_swap(self, v)


    def begin(self):
        """begin(vectori64 self) -> std::vector< int64_t >::iterator"""
        return _pysz.vectori64_begin(self)


    def end(self):
        """end(vectori64 self) -> std::vector< int64_t >::iterator"""
        return _pysz.vectori64_end(self)


    def rbegin(self):
        """rbegin(vectori64 self) -> std::vector< int64_t >::reverse_iterator"""
        return _pysz.vectori64_rbegin(self)


    def rend(self):
        """rend(vectori64 self) -> std::vector< int64_t >::reverse_iterator"""
        return _pysz.vectori64_rend(self)


    def clear(self):
        """clear(vectori64 self)"""
        return _pysz.vectori64_clear(self)


    def get_allocator(self):
        """get_allocator(vectori64 self) -> std::vector< int64_t >::allocator_type"""
        return _pysz.vectori64_get_allocator(self)


    def pop_back(self):
        """pop_back(vectori64 self)"""
        return _pysz.vectori64_pop_back(self)


    def erase(self, *args):
        """
        erase(vectori64 self, std::vector< int64_t >::iterator pos) -> std::vector< int64_t >::iterator
        erase(vectori64 self, std::vector< int64_t >::iterator first, std::vector< int64_t >::iterator last) -> std::vector< int64_t >::iterator
        """
        return _pysz.vectori64_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(int64_t)> self) -> vectori64
        __init__(std::vector<(int64_t)> self, vectori64 arg2) -> vectori64
        __init__(std::vector<(int64_t)> self, std::vector< int64_t >::size_type size) -> vectori64
        __init__(std::vector<(int64_t)> self, std::vector< int64_t >::size_type size, std::vector< int64_t >::value_type const & value) -> vectori64
        """
        this = _pysz.new_vectori64(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(vectori64 self, std::vector< int64_t >::value_type const & x)"""
        return _pysz.vectori64_push_back(self, x)


    def front(self):
        """front(vectori64 self) -> std::vector< int64_t >::value_type const &"""
        return _pysz.vectori64_front(self)


    def back(self):
        """back(vectori64 self) -> std::vector< int64_t >::value_type const &"""
        return _pysz.vectori64_back(self)


    def assign(self, n, x):
        """assign(vectori64 self, std::vector< int64_t >::size_type n, std::vector< int64_t >::value_type const & x)"""
        return _pysz.vectori64_assign(self, n, x)


    def resize(self, *args):
        """
        resize(vectori64 self, std::vector< int64_t >::size_type new_size)
        resize(vectori64 self, std::vector< int64_t >::size_type new_size, std::vector< int64_t >::value_type const & x)
        """
        return _pysz.vectori64_resize(self, *args)


    def insert(self, *args):
        """
        insert(vectori64 self, std::vector< int64_t >::iterator pos, std::vector< int64_t >::value_type const & x) -> std::vector< int64_t >::iterator
        insert(vectori64 self, std::vector< int64_t >::iterator pos, std::vector< int64_t >::size_type n, std::vector< int64_t >::value_type const & x)
        """
        return _pysz.vectori64_insert(self, *args)


    def reserve(self, n):
        """reserve(vectori64 self, std::vector< int64_t >::size_type n)"""
        return _pysz.vectori64_reserve(self, n)


    def capacity(self):
        """capacity(vectori64 self) -> std::vector< int64_t >::size_type"""
        return _pysz.vectori64_capacity(self)

    __swig_destroy__ = _pysz.delete_vectori64
    __del__ = lambda self: None
vectori64_swigregister = _pysz.vectori64_swigregister
vectori64_swigregister(vectori64)

class vectorui8(_object):
    """Proxy of C++ std::vector<(uint8_t)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vectorui8, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vectorui8, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(vectorui8 self) -> SwigPyIterator"""
        return _pysz.vectorui8_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(vectorui8 self) -> bool"""
        return _pysz.vectorui8___nonzero__(self)


    def __bool__(self):
        """__bool__(vectorui8 self) -> bool"""
        return _pysz.vectorui8___bool__(self)


    def __len__(self):
        """__len__(vectorui8 self) -> std::vector< uint8_t >::size_type"""
        return _pysz.vectorui8___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(vectorui8 self, std::vector< uint8_t >::difference_type i, std::vector< uint8_t >::difference_type j) -> vectorui8"""
        return _pysz.vectorui8___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(vectorui8 self, std::vector< uint8_t >::difference_type i, std::vector< uint8_t >::difference_type j)
        __setslice__(vectorui8 self, std::vector< uint8_t >::difference_type i, std::vector< uint8_t >::difference_type j, vectorui8 v)
        """
        return _pysz.vectorui8___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(vectorui8 self, std::vector< uint8_t >::difference_type i, std::vector< uint8_t >::difference_type j)"""
        return _pysz.vectorui8___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(vectorui8 self, std::vector< uint8_t >::difference_type i)
        __delitem__(vectorui8 self, PySliceObject * slice)
        """
        return _pysz.vectorui8___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(vectorui8 self, PySliceObject * slice) -> vectorui8
        __getitem__(vectorui8 self, std::vector< uint8_t >::difference_type i) -> std::vector< uint8_t >::value_type const &
        """
        return _pysz.vectorui8___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(vectorui8 self, PySliceObject * slice, vectorui8 v)
        __setitem__(vectorui8 self, PySliceObject * slice)
        __setitem__(vectorui8 self, std::vector< uint8_t >::difference_type i, std::vector< uint8_t >::value_type const & x)
        """
        return _pysz.vectorui8___setitem__(self, *args)


    def pop(self):
        """pop(vectorui8 self) -> std::vector< uint8_t >::value_type"""
        return _pysz.vectorui8_pop(self)


    def append(self, x):
        """append(vectorui8 self, std::vector< uint8_t >::value_type const & x)"""
        return _pysz.vectorui8_append(self, x)


    def empty(self):
        """empty(vectorui8 self) -> bool"""
        return _pysz.vectorui8_empty(self)


    def size(self):
        """size(vectorui8 self) -> std::vector< uint8_t >::size_type"""
        return _pysz.vectorui8_size(self)


    def swap(self, v):
        """swap(vectorui8 self, vectorui8 v)"""
        return _pysz.vectorui8_swap(self, v)


    def begin(self):
        """begin(vectorui8 self) -> std::vector< uint8_t >::iterator"""
        return _pysz.vectorui8_begin(self)


    def end(self):
        """end(vectorui8 self) -> std::vector< uint8_t >::iterator"""
        return _pysz.vectorui8_end(self)


    def rbegin(self):
        """rbegin(vectorui8 self) -> std::vector< uint8_t >::reverse_iterator"""
        return _pysz.vectorui8_rbegin(self)


    def rend(self):
        """rend(vectorui8 self) -> std::vector< uint8_t >::reverse_iterator"""
        return _pysz.vectorui8_rend(self)


    def clear(self):
        """clear(vectorui8 self)"""
        return _pysz.vectorui8_clear(self)


    def get_allocator(self):
        """get_allocator(vectorui8 self) -> std::vector< uint8_t >::allocator_type"""
        return _pysz.vectorui8_get_allocator(self)


    def pop_back(self):
        """pop_back(vectorui8 self)"""
        return _pysz.vectorui8_pop_back(self)


    def erase(self, *args):
        """
        erase(vectorui8 self, std::vector< uint8_t >::iterator pos) -> std::vector< uint8_t >::iterator
        erase(vectorui8 self, std::vector< uint8_t >::iterator first, std::vector< uint8_t >::iterator last) -> std::vector< uint8_t >::iterator
        """
        return _pysz.vectorui8_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(uint8_t)> self) -> vectorui8
        __init__(std::vector<(uint8_t)> self, vectorui8 arg2) -> vectorui8
        __init__(std::vector<(uint8_t)> self, std::vector< uint8_t >::size_type size) -> vectorui8
        __init__(std::vector<(uint8_t)> self, std::vector< uint8_t >::size_type size, std::vector< uint8_t >::value_type const & value) -> vectorui8
        """
        this = _pysz.new_vectorui8(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(vectorui8 self, std::vector< uint8_t >::value_type const & x)"""
        return _pysz.vectorui8_push_back(self, x)


    def front(self):
        """front(vectorui8 self) -> std::vector< uint8_t >::value_type const &"""
        return _pysz.vectorui8_front(self)


    def back(self):
        """back(vectorui8 self) -> std::vector< uint8_t >::value_type const &"""
        return _pysz.vectorui8_back(self)


    def assign(self, n, x):
        """assign(vectorui8 self, std::vector< uint8_t >::size_type n, std::vector< uint8_t >::value_type const & x)"""
        return _pysz.vectorui8_assign(self, n, x)


    def resize(self, *args):
        """
        resize(vectorui8 self, std::vector< uint8_t >::size_type new_size)
        resize(vectorui8 self, std::vector< uint8_t >::size_type new_size, std::vector< uint8_t >::value_type const & x)
        """
        return _pysz.vectorui8_resize(self, *args)


    def insert(self, *args):
        """
        insert(vectorui8 self, std::vector< uint8_t >::iterator pos, std::vector< uint8_t >::value_type const & x) -> std::vector< uint8_t >::iterator
        insert(vectorui8 self, std::vector< uint8_t >::iterator pos, std::vector< uint8_t >::size_type n, std::vector< uint8_t >::value_type const & x)
        """
        return _pysz.vectorui8_insert(self, *args)


    def reserve(self, n):
        """reserve(vectorui8 self, std::vector< uint8_t >::size_type n)"""
        return _pysz.vectorui8_reserve(self, n)


    def capacity(self):
        """capacity(vectorui8 self) -> std::vector< uint8_t >::size_type"""
        return _pysz.vectorui8_capacity(self)

    __swig_destroy__ = _pysz.delete_vectorui8
    __del__ = lambda self: None
vectorui8_swigregister = _pysz.vectorui8_swigregister
vectorui8_swigregister(vectorui8)

class vectorui16(_object):
    """Proxy of C++ std::vector<(uint16_t)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vectorui16, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vectorui16, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(vectorui16 self) -> SwigPyIterator"""
        return _pysz.vectorui16_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(vectorui16 self) -> bool"""
        return _pysz.vectorui16___nonzero__(self)


    def __bool__(self):
        """__bool__(vectorui16 self) -> bool"""
        return _pysz.vectorui16___bool__(self)


    def __len__(self):
        """__len__(vectorui16 self) -> std::vector< uint16_t >::size_type"""
        return _pysz.vectorui16___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(vectorui16 self, std::vector< uint16_t >::difference_type i, std::vector< uint16_t >::difference_type j) -> vectorui16"""
        return _pysz.vectorui16___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(vectorui16 self, std::vector< uint16_t >::difference_type i, std::vector< uint16_t >::difference_type j)
        __setslice__(vectorui16 self, std::vector< uint16_t >::difference_type i, std::vector< uint16_t >::difference_type j, vectorui16 v)
        """
        return _pysz.vectorui16___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(vectorui16 self, std::vector< uint16_t >::difference_type i, std::vector< uint16_t >::difference_type j)"""
        return _pysz.vectorui16___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(vectorui16 self, std::vector< uint16_t >::difference_type i)
        __delitem__(vectorui16 self, PySliceObject * slice)
        """
        return _pysz.vectorui16___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(vectorui16 self, PySliceObject * slice) -> vectorui16
        __getitem__(vectorui16 self, std::vector< uint16_t >::difference_type i) -> std::vector< uint16_t >::value_type const &
        """
        return _pysz.vectorui16___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(vectorui16 self, PySliceObject * slice, vectorui16 v)
        __setitem__(vectorui16 self, PySliceObject * slice)
        __setitem__(vectorui16 self, std::vector< uint16_t >::difference_type i, std::vector< uint16_t >::value_type const & x)
        """
        return _pysz.vectorui16___setitem__(self, *args)


    def pop(self):
        """pop(vectorui16 self) -> std::vector< uint16_t >::value_type"""
        return _pysz.vectorui16_pop(self)


    def append(self, x):
        """append(vectorui16 self, std::vector< uint16_t >::value_type const & x)"""
        return _pysz.vectorui16_append(self, x)


    def empty(self):
        """empty(vectorui16 self) -> bool"""
        return _pysz.vectorui16_empty(self)


    def size(self):
        """size(vectorui16 self) -> std::vector< uint16_t >::size_type"""
        return _pysz.vectorui16_size(self)


    def swap(self, v):
        """swap(vectorui16 self, vectorui16 v)"""
        return _pysz.vectorui16_swap(self, v)


    def begin(self):
        """begin(vectorui16 self) -> std::vector< uint16_t >::iterator"""
        return _pysz.vectorui16_begin(self)


    def end(self):
        """end(vectorui16 self) -> std::vector< uint16_t >::iterator"""
        return _pysz.vectorui16_end(self)


    def rbegin(self):
        """rbegin(vectorui16 self) -> std::vector< uint16_t >::reverse_iterator"""
        return _pysz.vectorui16_rbegin(self)


    def rend(self):
        """rend(vectorui16 self) -> std::vector< uint16_t >::reverse_iterator"""
        return _pysz.vectorui16_rend(self)


    def clear(self):
        """clear(vectorui16 self)"""
        return _pysz.vectorui16_clear(self)


    def get_allocator(self):
        """get_allocator(vectorui16 self) -> std::vector< uint16_t >::allocator_type"""
        return _pysz.vectorui16_get_allocator(self)


    def pop_back(self):
        """pop_back(vectorui16 self)"""
        return _pysz.vectorui16_pop_back(self)


    def erase(self, *args):
        """
        erase(vectorui16 self, std::vector< uint16_t >::iterator pos) -> std::vector< uint16_t >::iterator
        erase(vectorui16 self, std::vector< uint16_t >::iterator first, std::vector< uint16_t >::iterator last) -> std::vector< uint16_t >::iterator
        """
        return _pysz.vectorui16_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(uint16_t)> self) -> vectorui16
        __init__(std::vector<(uint16_t)> self, vectorui16 arg2) -> vectorui16
        __init__(std::vector<(uint16_t)> self, std::vector< uint16_t >::size_type size) -> vectorui16
        __init__(std::vector<(uint16_t)> self, std::vector< uint16_t >::size_type size, std::vector< uint16_t >::value_type const & value) -> vectorui16
        """
        this = _pysz.new_vectorui16(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(vectorui16 self, std::vector< uint16_t >::value_type const & x)"""
        return _pysz.vectorui16_push_back(self, x)


    def front(self):
        """front(vectorui16 self) -> std::vector< uint16_t >::value_type const &"""
        return _pysz.vectorui16_front(self)


    def back(self):
        """back(vectorui16 self) -> std::vector< uint16_t >::value_type const &"""
        return _pysz.vectorui16_back(self)


    def assign(self, n, x):
        """assign(vectorui16 self, std::vector< uint16_t >::size_type n, std::vector< uint16_t >::value_type const & x)"""
        return _pysz.vectorui16_assign(self, n, x)


    def resize(self, *args):
        """
        resize(vectorui16 self, std::vector< uint16_t >::size_type new_size)
        resize(vectorui16 self, std::vector< uint16_t >::size_type new_size, std::vector< uint16_t >::value_type const & x)
        """
        return _pysz.vectorui16_resize(self, *args)


    def insert(self, *args):
        """
        insert(vectorui16 self, std::vector< uint16_t >::iterator pos, std::vector< uint16_t >::value_type const & x) -> std::vector< uint16_t >::iterator
        insert(vectorui16 self, std::vector< uint16_t >::iterator pos, std::vector< uint16_t >::size_type n, std::vector< uint16_t >::value_type const & x)
        """
        return _pysz.vectorui16_insert(self, *args)


    def reserve(self, n):
        """reserve(vectorui16 self, std::vector< uint16_t >::size_type n)"""
        return _pysz.vectorui16_reserve(self, n)


    def capacity(self):
        """capacity(vectorui16 self) -> std::vector< uint16_t >::size_type"""
        return _pysz.vectorui16_capacity(self)

    __swig_destroy__ = _pysz.delete_vectorui16
    __del__ = lambda self: None
vectorui16_swigregister = _pysz.vectorui16_swigregister
vectorui16_swigregister(vectorui16)

class vectorui32(_object):
    """Proxy of C++ std::vector<(uint32_t)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vectorui32, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vectorui32, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(vectorui32 self) -> SwigPyIterator"""
        return _pysz.vectorui32_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(vectorui32 self) -> bool"""
        return _pysz.vectorui32___nonzero__(self)


    def __bool__(self):
        """__bool__(vectorui32 self) -> bool"""
        return _pysz.vectorui32___bool__(self)


    def __len__(self):
        """__len__(vectorui32 self) -> std::vector< uint32_t >::size_type"""
        return _pysz.vectorui32___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(vectorui32 self, std::vector< uint32_t >::difference_type i, std::vector< uint32_t >::difference_type j) -> vectorui32"""
        return _pysz.vectorui32___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(vectorui32 self, std::vector< uint32_t >::difference_type i, std::vector< uint32_t >::difference_type j)
        __setslice__(vectorui32 self, std::vector< uint32_t >::difference_type i, std::vector< uint32_t >::difference_type j, vectorui32 v)
        """
        return _pysz.vectorui32___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(vectorui32 self, std::vector< uint32_t >::difference_type i, std::vector< uint32_t >::difference_type j)"""
        return _pysz.vectorui32___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(vectorui32 self, std::vector< uint32_t >::difference_type i)
        __delitem__(vectorui32 self, PySliceObject * slice)
        """
        return _pysz.vectorui32___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(vectorui32 self, PySliceObject * slice) -> vectorui32
        __getitem__(vectorui32 self, std::vector< uint32_t >::difference_type i) -> std::vector< uint32_t >::value_type const &
        """
        return _pysz.vectorui32___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(vectorui32 self, PySliceObject * slice, vectorui32 v)
        __setitem__(vectorui32 self, PySliceObject * slice)
        __setitem__(vectorui32 self, std::vector< uint32_t >::difference_type i, std::vector< uint32_t >::value_type const & x)
        """
        return _pysz.vectorui32___setitem__(self, *args)


    def pop(self):
        """pop(vectorui32 self) -> std::vector< uint32_t >::value_type"""
        return _pysz.vectorui32_pop(self)


    def append(self, x):
        """append(vectorui32 self, std::vector< uint32_t >::value_type const & x)"""
        return _pysz.vectorui32_append(self, x)


    def empty(self):
        """empty(vectorui32 self) -> bool"""
        return _pysz.vectorui32_empty(self)


    def size(self):
        """size(vectorui32 self) -> std::vector< uint32_t >::size_type"""
        return _pysz.vectorui32_size(self)


    def swap(self, v):
        """swap(vectorui32 self, vectorui32 v)"""
        return _pysz.vectorui32_swap(self, v)


    def begin(self):
        """begin(vectorui32 self) -> std::vector< uint32_t >::iterator"""
        return _pysz.vectorui32_begin(self)


    def end(self):
        """end(vectorui32 self) -> std::vector< uint32_t >::iterator"""
        return _pysz.vectorui32_end(self)


    def rbegin(self):
        """rbegin(vectorui32 self) -> std::vector< uint32_t >::reverse_iterator"""
        return _pysz.vectorui32_rbegin(self)


    def rend(self):
        """rend(vectorui32 self) -> std::vector< uint32_t >::reverse_iterator"""
        return _pysz.vectorui32_rend(self)


    def clear(self):
        """clear(vectorui32 self)"""
        return _pysz.vectorui32_clear(self)


    def get_allocator(self):
        """get_allocator(vectorui32 self) -> std::vector< uint32_t >::allocator_type"""
        return _pysz.vectorui32_get_allocator(self)


    def pop_back(self):
        """pop_back(vectorui32 self)"""
        return _pysz.vectorui32_pop_back(self)


    def erase(self, *args):
        """
        erase(vectorui32 self, std::vector< uint32_t >::iterator pos) -> std::vector< uint32_t >::iterator
        erase(vectorui32 self, std::vector< uint32_t >::iterator first, std::vector< uint32_t >::iterator last) -> std::vector< uint32_t >::iterator
        """
        return _pysz.vectorui32_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(uint32_t)> self) -> vectorui32
        __init__(std::vector<(uint32_t)> self, vectorui32 arg2) -> vectorui32
        __init__(std::vector<(uint32_t)> self, std::vector< uint32_t >::size_type size) -> vectorui32
        __init__(std::vector<(uint32_t)> self, std::vector< uint32_t >::size_type size, std::vector< uint32_t >::value_type const & value) -> vectorui32
        """
        this = _pysz.new_vectorui32(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(vectorui32 self, std::vector< uint32_t >::value_type const & x)"""
        return _pysz.vectorui32_push_back(self, x)


    def front(self):
        """front(vectorui32 self) -> std::vector< uint32_t >::value_type const &"""
        return _pysz.vectorui32_front(self)


    def back(self):
        """back(vectorui32 self) -> std::vector< uint32_t >::value_type const &"""
        return _pysz.vectorui32_back(self)


    def assign(self, n, x):
        """assign(vectorui32 self, std::vector< uint32_t >::size_type n, std::vector< uint32_t >::value_type const & x)"""
        return _pysz.vectorui32_assign(self, n, x)


    def resize(self, *args):
        """
        resize(vectorui32 self, std::vector< uint32_t >::size_type new_size)
        resize(vectorui32 self, std::vector< uint32_t >::size_type new_size, std::vector< uint32_t >::value_type const & x)
        """
        return _pysz.vectorui32_resize(self, *args)


    def insert(self, *args):
        """
        insert(vectorui32 self, std::vector< uint32_t >::iterator pos, std::vector< uint32_t >::value_type const & x) -> std::vector< uint32_t >::iterator
        insert(vectorui32 self, std::vector< uint32_t >::iterator pos, std::vector< uint32_t >::size_type n, std::vector< uint32_t >::value_type const & x)
        """
        return _pysz.vectorui32_insert(self, *args)


    def reserve(self, n):
        """reserve(vectorui32 self, std::vector< uint32_t >::size_type n)"""
        return _pysz.vectorui32_reserve(self, n)


    def capacity(self):
        """capacity(vectorui32 self) -> std::vector< uint32_t >::size_type"""
        return _pysz.vectorui32_capacity(self)

    __swig_destroy__ = _pysz.delete_vectorui32
    __del__ = lambda self: None
vectorui32_swigregister = _pysz.vectorui32_swigregister
vectorui32_swigregister(vectorui32)

class vectorui64(_object):
    """Proxy of C++ std::vector<(uint64_t)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vectorui64, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vectorui64, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(vectorui64 self) -> SwigPyIterator"""
        return _pysz.vectorui64_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(vectorui64 self) -> bool"""
        return _pysz.vectorui64___nonzero__(self)


    def __bool__(self):
        """__bool__(vectorui64 self) -> bool"""
        return _pysz.vectorui64___bool__(self)


    def __len__(self):
        """__len__(vectorui64 self) -> std::vector< uint64_t >::size_type"""
        return _pysz.vectorui64___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(vectorui64 self, std::vector< uint64_t >::difference_type i, std::vector< uint64_t >::difference_type j) -> vectorui64"""
        return _pysz.vectorui64___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(vectorui64 self, std::vector< uint64_t >::difference_type i, std::vector< uint64_t >::difference_type j)
        __setslice__(vectorui64 self, std::vector< uint64_t >::difference_type i, std::vector< uint64_t >::difference_type j, vectorui64 v)
        """
        return _pysz.vectorui64___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(vectorui64 self, std::vector< uint64_t >::difference_type i, std::vector< uint64_t >::difference_type j)"""
        return _pysz.vectorui64___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(vectorui64 self, std::vector< uint64_t >::difference_type i)
        __delitem__(vectorui64 self, PySliceObject * slice)
        """
        return _pysz.vectorui64___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(vectorui64 self, PySliceObject * slice) -> vectorui64
        __getitem__(vectorui64 self, std::vector< uint64_t >::difference_type i) -> std::vector< uint64_t >::value_type const &
        """
        return _pysz.vectorui64___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(vectorui64 self, PySliceObject * slice, vectorui64 v)
        __setitem__(vectorui64 self, PySliceObject * slice)
        __setitem__(vectorui64 self, std::vector< uint64_t >::difference_type i, std::vector< uint64_t >::value_type const & x)
        """
        return _pysz.vectorui64___setitem__(self, *args)


    def pop(self):
        """pop(vectorui64 self) -> std::vector< uint64_t >::value_type"""
        return _pysz.vectorui64_pop(self)


    def append(self, x):
        """append(vectorui64 self, std::vector< uint64_t >::value_type const & x)"""
        return _pysz.vectorui64_append(self, x)


    def empty(self):
        """empty(vectorui64 self) -> bool"""
        return _pysz.vectorui64_empty(self)


    def size(self):
        """size(vectorui64 self) -> std::vector< uint64_t >::size_type"""
        return _pysz.vectorui64_size(self)


    def swap(self, v):
        """swap(vectorui64 self, vectorui64 v)"""
        return _pysz.vectorui64_swap(self, v)


    def begin(self):
        """begin(vectorui64 self) -> std::vector< uint64_t >::iterator"""
        return _pysz.vectorui64_begin(self)


    def end(self):
        """end(vectorui64 self) -> std::vector< uint64_t >::iterator"""
        return _pysz.vectorui64_end(self)


    def rbegin(self):
        """rbegin(vectorui64 self) -> std::vector< uint64_t >::reverse_iterator"""
        return _pysz.vectorui64_rbegin(self)


    def rend(self):
        """rend(vectorui64 self) -> std::vector< uint64_t >::reverse_iterator"""
        return _pysz.vectorui64_rend(self)


    def clear(self):
        """clear(vectorui64 self)"""
        return _pysz.vectorui64_clear(self)


    def get_allocator(self):
        """get_allocator(vectorui64 self) -> std::vector< uint64_t >::allocator_type"""
        return _pysz.vectorui64_get_allocator(self)


    def pop_back(self):
        """pop_back(vectorui64 self)"""
        return _pysz.vectorui64_pop_back(self)


    def erase(self, *args):
        """
        erase(vectorui64 self, std::vector< uint64_t >::iterator pos) -> std::vector< uint64_t >::iterator
        erase(vectorui64 self, std::vector< uint64_t >::iterator first, std::vector< uint64_t >::iterator last) -> std::vector< uint64_t >::iterator
        """
        return _pysz.vectorui64_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(uint64_t)> self) -> vectorui64
        __init__(std::vector<(uint64_t)> self, vectorui64 arg2) -> vectorui64
        __init__(std::vector<(uint64_t)> self, std::vector< uint64_t >::size_type size) -> vectorui64
        __init__(std::vector<(uint64_t)> self, std::vector< uint64_t >::size_type size, std::vector< uint64_t >::value_type const & value) -> vectorui64
        """
        this = _pysz.new_vectorui64(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(vectorui64 self, std::vector< uint64_t >::value_type const & x)"""
        return _pysz.vectorui64_push_back(self, x)


    def front(self):
        """front(vectorui64 self) -> std::vector< uint64_t >::value_type const &"""
        return _pysz.vectorui64_front(self)


    def back(self):
        """back(vectorui64 self) -> std::vector< uint64_t >::value_type const &"""
        return _pysz.vectorui64_back(self)


    def assign(self, n, x):
        """assign(vectorui64 self, std::vector< uint64_t >::size_type n, std::vector< uint64_t >::value_type const & x)"""
        return _pysz.vectorui64_assign(self, n, x)


    def resize(self, *args):
        """
        resize(vectorui64 self, std::vector< uint64_t >::size_type new_size)
        resize(vectorui64 self, std::vector< uint64_t >::size_type new_size, std::vector< uint64_t >::value_type const & x)
        """
        return _pysz.vectorui64_resize(self, *args)


    def insert(self, *args):
        """
        insert(vectorui64 self, std::vector< uint64_t >::iterator pos, std::vector< uint64_t >::value_type const & x) -> std::vector< uint64_t >::iterator
        insert(vectorui64 self, std::vector< uint64_t >::iterator pos, std::vector< uint64_t >::size_type n, std::vector< uint64_t >::value_type const & x)
        """
        return _pysz.vectorui64_insert(self, *args)


    def reserve(self, n):
        """reserve(vectorui64 self, std::vector< uint64_t >::size_type n)"""
        return _pysz.vectorui64_reserve(self, n)


    def capacity(self):
        """capacity(vectorui64 self) -> std::vector< uint64_t >::size_type"""
        return _pysz.vectorui64_capacity(self)

    __swig_destroy__ = _pysz.delete_vectorui64
    __del__ = lambda self: None
vectorui64_swigregister = _pysz.vectorui64_swigregister
vectorui64_swigregister(vectorui64)

class vectorf(_object):
    """Proxy of C++ std::vector<(float)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vectorf, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vectorf, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(vectorf self) -> SwigPyIterator"""
        return _pysz.vectorf_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(vectorf self) -> bool"""
        return _pysz.vectorf___nonzero__(self)


    def __bool__(self):
        """__bool__(vectorf self) -> bool"""
        return _pysz.vectorf___bool__(self)


    def __len__(self):
        """__len__(vectorf self) -> std::vector< float >::size_type"""
        return _pysz.vectorf___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(vectorf self, std::vector< float >::difference_type i, std::vector< float >::difference_type j) -> vectorf"""
        return _pysz.vectorf___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(vectorf self, std::vector< float >::difference_type i, std::vector< float >::difference_type j)
        __setslice__(vectorf self, std::vector< float >::difference_type i, std::vector< float >::difference_type j, vectorf v)
        """
        return _pysz.vectorf___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(vectorf self, std::vector< float >::difference_type i, std::vector< float >::difference_type j)"""
        return _pysz.vectorf___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(vectorf self, std::vector< float >::difference_type i)
        __delitem__(vectorf self, PySliceObject * slice)
        """
        return _pysz.vectorf___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(vectorf self, PySliceObject * slice) -> vectorf
        __getitem__(vectorf self, std::vector< float >::difference_type i) -> std::vector< float >::value_type const &
        """
        return _pysz.vectorf___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(vectorf self, PySliceObject * slice, vectorf v)
        __setitem__(vectorf self, PySliceObject * slice)
        __setitem__(vectorf self, std::vector< float >::difference_type i, std::vector< float >::value_type const & x)
        """
        return _pysz.vectorf___setitem__(self, *args)


    def pop(self):
        """pop(vectorf self) -> std::vector< float >::value_type"""
        return _pysz.vectorf_pop(self)


    def append(self, x):
        """append(vectorf self, std::vector< float >::value_type const & x)"""
        return _pysz.vectorf_append(self, x)


    def empty(self):
        """empty(vectorf self) -> bool"""
        return _pysz.vectorf_empty(self)


    def size(self):
        """size(vectorf self) -> std::vector< float >::size_type"""
        return _pysz.vectorf_size(self)


    def swap(self, v):
        """swap(vectorf self, vectorf v)"""
        return _pysz.vectorf_swap(self, v)


    def begin(self):
        """begin(vectorf self) -> std::vector< float >::iterator"""
        return _pysz.vectorf_begin(self)


    def end(self):
        """end(vectorf self) -> std::vector< float >::iterator"""
        return _pysz.vectorf_end(self)


    def rbegin(self):
        """rbegin(vectorf self) -> std::vector< float >::reverse_iterator"""
        return _pysz.vectorf_rbegin(self)


    def rend(self):
        """rend(vectorf self) -> std::vector< float >::reverse_iterator"""
        return _pysz.vectorf_rend(self)


    def clear(self):
        """clear(vectorf self)"""
        return _pysz.vectorf_clear(self)


    def get_allocator(self):
        """get_allocator(vectorf self) -> std::vector< float >::allocator_type"""
        return _pysz.vectorf_get_allocator(self)


    def pop_back(self):
        """pop_back(vectorf self)"""
        return _pysz.vectorf_pop_back(self)


    def erase(self, *args):
        """
        erase(vectorf self, std::vector< float >::iterator pos) -> std::vector< float >::iterator
        erase(vectorf self, std::vector< float >::iterator first, std::vector< float >::iterator last) -> std::vector< float >::iterator
        """
        return _pysz.vectorf_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(float)> self) -> vectorf
        __init__(std::vector<(float)> self, vectorf arg2) -> vectorf
        __init__(std::vector<(float)> self, std::vector< float >::size_type size) -> vectorf
        __init__(std::vector<(float)> self, std::vector< float >::size_type size, std::vector< float >::value_type const & value) -> vectorf
        """
        this = _pysz.new_vectorf(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(vectorf self, std::vector< float >::value_type const & x)"""
        return _pysz.vectorf_push_back(self, x)


    def front(self):
        """front(vectorf self) -> std::vector< float >::value_type const &"""
        return _pysz.vectorf_front(self)


    def back(self):
        """back(vectorf self) -> std::vector< float >::value_type const &"""
        return _pysz.vectorf_back(self)


    def assign(self, n, x):
        """assign(vectorf self, std::vector< float >::size_type n, std::vector< float >::value_type const & x)"""
        return _pysz.vectorf_assign(self, n, x)


    def resize(self, *args):
        """
        resize(vectorf self, std::vector< float >::size_type new_size)
        resize(vectorf self, std::vector< float >::size_type new_size, std::vector< float >::value_type const & x)
        """
        return _pysz.vectorf_resize(self, *args)


    def insert(self, *args):
        """
        insert(vectorf self, std::vector< float >::iterator pos, std::vector< float >::value_type const & x) -> std::vector< float >::iterator
        insert(vectorf self, std::vector< float >::iterator pos, std::vector< float >::size_type n, std::vector< float >::value_type const & x)
        """
        return _pysz.vectorf_insert(self, *args)


    def reserve(self, n):
        """reserve(vectorf self, std::vector< float >::size_type n)"""
        return _pysz.vectorf_reserve(self, n)


    def capacity(self):
        """capacity(vectorf self) -> std::vector< float >::size_type"""
        return _pysz.vectorf_capacity(self)

    __swig_destroy__ = _pysz.delete_vectorf
    __del__ = lambda self: None
vectorf_swigregister = _pysz.vectorf_swigregister
vectorf_swigregister(vectorf)

class vectord(_object):
    """Proxy of C++ std::vector<(double)> class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vectord, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vectord, name)
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(vectord self) -> SwigPyIterator"""
        return _pysz.vectord_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(vectord self) -> bool"""
        return _pysz.vectord___nonzero__(self)


    def __bool__(self):
        """__bool__(vectord self) -> bool"""
        return _pysz.vectord___bool__(self)


    def __len__(self):
        """__len__(vectord self) -> std::vector< double >::size_type"""
        return _pysz.vectord___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(vectord self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> vectord"""
        return _pysz.vectord___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(vectord self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)
        __setslice__(vectord self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, vectord v)
        """
        return _pysz.vectord___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(vectord self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"""
        return _pysz.vectord___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(vectord self, std::vector< double >::difference_type i)
        __delitem__(vectord self, PySliceObject * slice)
        """
        return _pysz.vectord___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(vectord self, PySliceObject * slice) -> vectord
        __getitem__(vectord self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &
        """
        return _pysz.vectord___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(vectord self, PySliceObject * slice, vectord v)
        __setitem__(vectord self, PySliceObject * slice)
        __setitem__(vectord self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)
        """
        return _pysz.vectord___setitem__(self, *args)


    def pop(self):
        """pop(vectord self) -> std::vector< double >::value_type"""
        return _pysz.vectord_pop(self)


    def append(self, x):
        """append(vectord self, std::vector< double >::value_type const & x)"""
        return _pysz.vectord_append(self, x)


    def empty(self):
        """empty(vectord self) -> bool"""
        return _pysz.vectord_empty(self)


    def size(self):
        """size(vectord self) -> std::vector< double >::size_type"""
        return _pysz.vectord_size(self)


    def swap(self, v):
        """swap(vectord self, vectord v)"""
        return _pysz.vectord_swap(self, v)


    def begin(self):
        """begin(vectord self) -> std::vector< double >::iterator"""
        return _pysz.vectord_begin(self)


    def end(self):
        """end(vectord self) -> std::vector< double >::iterator"""
        return _pysz.vectord_end(self)


    def rbegin(self):
        """rbegin(vectord self) -> std::vector< double >::reverse_iterator"""
        return _pysz.vectord_rbegin(self)


    def rend(self):
        """rend(vectord self) -> std::vector< double >::reverse_iterator"""
        return _pysz.vectord_rend(self)


    def clear(self):
        """clear(vectord self)"""
        return _pysz.vectord_clear(self)


    def get_allocator(self):
        """get_allocator(vectord self) -> std::vector< double >::allocator_type"""
        return _pysz.vectord_get_allocator(self)


    def pop_back(self):
        """pop_back(vectord self)"""
        return _pysz.vectord_pop_back(self)


    def erase(self, *args):
        """
        erase(vectord self, std::vector< double >::iterator pos) -> std::vector< double >::iterator
        erase(vectord self, std::vector< double >::iterator first, std::vector< double >::iterator last) -> std::vector< double >::iterator
        """
        return _pysz.vectord_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(double)> self) -> vectord
        __init__(std::vector<(double)> self, vectord arg2) -> vectord
        __init__(std::vector<(double)> self, std::vector< double >::size_type size) -> vectord
        __init__(std::vector<(double)> self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> vectord
        """
        this = _pysz.new_vectord(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(vectord self, std::vector< double >::value_type const & x)"""
        return _pysz.vectord_push_back(self, x)


    def front(self):
        """front(vectord self) -> std::vector< double >::value_type const &"""
        return _pysz.vectord_front(self)


    def back(self):
        """back(vectord self) -> std::vector< double >::value_type const &"""
        return _pysz.vectord_back(self)


    def assign(self, n, x):
        """assign(vectord self, std::vector< double >::size_type n, std::vector< double >::value_type const & x)"""
        return _pysz.vectord_assign(self, n, x)


    def resize(self, *args):
        """
        resize(vectord self, std::vector< double >::size_type new_size)
        resize(vectord self, std::vector< double >::size_type new_size, std::vector< double >::value_type const & x)
        """
        return _pysz.vectord_resize(self, *args)


    def insert(self, *args):
        """
        insert(vectord self, std::vector< double >::iterator pos, std::vector< double >::value_type const & x) -> std::vector< double >::iterator
        insert(vectord self, std::vector< double >::iterator pos, std::vector< double >::size_type n, std::vector< double >::value_type const & x)
        """
        return _pysz.vectord_insert(self, *args)


    def reserve(self, n):
        """reserve(vectord self, std::vector< double >::size_type n)"""
        return _pysz.vectord_reserve(self, n)


    def capacity(self):
        """capacity(vectord self) -> std::vector< double >::size_type"""
        return _pysz.vectord_capacity(self)

    __swig_destroy__ = _pysz.delete_vectord
    __del__ = lambda self: None
vectord_swigregister = _pysz.vectord_swigregister
vectord_swigregister(vectord)

class Config(_object):
    """Proxy of C++ Config class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Config, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Config, name)
    __repr__ = _swig_repr
    __swig_setmethods__["params"] = _pysz.Config_params_set
    __swig_getmethods__["params"] = _pysz.Config_params_get
    if _newclass:
        params = _swig_property(_pysz.Config_params_get, _pysz.Config_params_set)
    __swig_setmethods__["app"] = _pysz.Config_app_set
    __swig_getmethods__["app"] = _pysz.Config_app_get
    if _newclass:
        app = _swig_property(_pysz.Config_app_get, _pysz.Config_app_set)

    def __init__(self):
        """__init__(Config self) -> Config"""
        this = _pysz.new_Config()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pysz.delete_Config
    __del__ = lambda self: None
Config_swigregister = _pysz.Config_swigregister
Config_swigregister(Config)

class ConfigBuilder(_object):
    """Proxy of C++ ConfigBuilder class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConfigBuilder, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConfigBuilder, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ConfigBuilder self) -> ConfigBuilder
        __init__(ConfigBuilder self, std::string const & config_file_path) -> ConfigBuilder
        """
        this = _pysz.new_ConfigBuilder(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def build(self):
        """build(ConfigBuilder self) -> Config"""
        return _pysz.ConfigBuilder_build(self)


    def app(self, app):
        """app(ConfigBuilder self, std::string app) -> ConfigBuilder"""
        return _pysz.ConfigBuilder_app(self, app)


    def absErrBound(self, value):
        """absErrBound(ConfigBuilder self, double value) -> ConfigBuilder"""
        return _pysz.ConfigBuilder_absErrBound(self, value)


    def dataType(self, value):
        """dataType(ConfigBuilder self, int value) -> ConfigBuilder"""
        return _pysz.ConfigBuilder_dataType(self, value)


    def errorBoundMode(self, value):
        """errorBoundMode(ConfigBuilder self, int value) -> ConfigBuilder"""
        return _pysz.ConfigBuilder_errorBoundMode(self, value)


    def gzipMode(self, value):
        """gzipMode(ConfigBuilder self, int value) -> ConfigBuilder"""
        return _pysz.ConfigBuilder_gzipMode(self, value)


    def losslessCompressor(self, value):
        """losslessCompressor(ConfigBuilder self, int value) -> ConfigBuilder"""
        return _pysz.ConfigBuilder_losslessCompressor(self, value)


    def maxRangeRadius(self, value):
        """maxRangeRadius(ConfigBuilder self, unsigned int value) -> ConfigBuilder"""
        return _pysz.ConfigBuilder_maxRangeRadius(self, value)


    def max_quant_intervals(self, value):
        """max_quant_intervals(ConfigBuilder self, unsigned int value) -> ConfigBuilder"""
        return _pysz.ConfigBuilder_max_quant_intervals(self, value)


    def predThreshold(self, value):
        """predThreshold(ConfigBuilder self, float value) -> ConfigBuilder"""
        return _pysz.ConfigBuilder_predThreshold(self, value)


    def predictionMode(self, value):
        """predictionMode(ConfigBuilder self, int value) -> ConfigBuilder"""
        return _pysz.ConfigBuilder_predictionMode(self, value)


    def psnr(self, value):
        """psnr(ConfigBuilder self, double value) -> ConfigBuilder"""
        return _pysz.ConfigBuilder_psnr(self, value)


    def pw_relBoundRatio(self, value):
        """pw_relBoundRatio(ConfigBuilder self, double value) -> ConfigBuilder"""
        return _pysz.ConfigBuilder_pw_relBoundRatio(self, value)


    def pwr_type(self, value):
        """pwr_type(ConfigBuilder self, int value) -> ConfigBuilder"""
        return _pysz.ConfigBuilder_pwr_type(self, value)


    def quantization_intervals(self, value):
        """quantization_intervals(ConfigBuilder self, unsigned int value) -> ConfigBuilder"""
        return _pysz.ConfigBuilder_quantization_intervals(self, value)


    def randomAccess(self, value):
        """randomAccess(ConfigBuilder self, int value) -> ConfigBuilder"""
        return _pysz.ConfigBuilder_randomAccess(self, value)


    def relBoundRatio(self, value):
        """relBoundRatio(ConfigBuilder self, double value) -> ConfigBuilder"""
        return _pysz.ConfigBuilder_relBoundRatio(self, value)


    def sampleDistance(self, value):
        """sampleDistance(ConfigBuilder self, int value) -> ConfigBuilder"""
        return _pysz.ConfigBuilder_sampleDistance(self, value)


    def segment_size(self, value):
        """segment_size(ConfigBuilder self, int value) -> ConfigBuilder"""
        return _pysz.ConfigBuilder_segment_size(self, value)


    def snapshotCmprStep(self, value):
        """snapshotCmprStep(ConfigBuilder self, int value) -> ConfigBuilder"""
        return _pysz.ConfigBuilder_snapshotCmprStep(self, value)


    def sol_ID(self, value):
        """sol_ID(ConfigBuilder self, int value) -> ConfigBuilder"""
        return _pysz.ConfigBuilder_sol_ID(self, value)


    def szMode(self, value):
        """szMode(ConfigBuilder self, int value) -> ConfigBuilder"""
        return _pysz.ConfigBuilder_szMode(self, value)


    def accelerate_pw_rel_compression(self, value):
        """accelerate_pw_rel_compression(ConfigBuilder self, int value) -> ConfigBuilder"""
        return _pysz.ConfigBuilder_accelerate_pw_rel_compression(self, value)


    def plus_bits(self, value):
        """plus_bits(ConfigBuilder self, int value) -> ConfigBuilder"""
        return _pysz.ConfigBuilder_plus_bits(self, value)

    __swig_destroy__ = _pysz.delete_ConfigBuilder
    __del__ = lambda self: None
ConfigBuilder_swigregister = _pysz.ConfigBuilder_swigregister
ConfigBuilder_swigregister(ConfigBuilder)

class ExaFELConfigBuilder(_object):
    """Proxy of C++ ExaFELConfigBuilder class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExaFELConfigBuilder, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ExaFELConfigBuilder, name)
    __repr__ = _swig_repr

    def build(self):
        """build(ExaFELConfigBuilder self) -> exafelSZ_params *"""
        return _pysz.ExaFELConfigBuilder_build(self)

    __swig_setmethods__["binSize"] = _pysz.ExaFELConfigBuilder_binSize_set
    __swig_getmethods__["binSize"] = _pysz.ExaFELConfigBuilder_binSize_get
    if _newclass:
        binSize = _swig_property(_pysz.ExaFELConfigBuilder_binSize_get, _pysz.ExaFELConfigBuilder_binSize_set)
    __swig_setmethods__["tolerance"] = _pysz.ExaFELConfigBuilder_tolerance_set
    __swig_getmethods__["tolerance"] = _pysz.ExaFELConfigBuilder_tolerance_get
    if _newclass:
        tolerance = _swig_property(_pysz.ExaFELConfigBuilder_tolerance_get, _pysz.ExaFELConfigBuilder_tolerance_set)
    __swig_setmethods__["szDim"] = _pysz.ExaFELConfigBuilder_szDim_set
    __swig_getmethods__["szDim"] = _pysz.ExaFELConfigBuilder_szDim_get
    if _newclass:
        szDim = _swig_property(_pysz.ExaFELConfigBuilder_szDim_get, _pysz.ExaFELConfigBuilder_szDim_set)
    __swig_setmethods__["peakSize"] = _pysz.ExaFELConfigBuilder_peakSize_set
    __swig_getmethods__["peakSize"] = _pysz.ExaFELConfigBuilder_peakSize_get
    if _newclass:
        peakSize = _swig_property(_pysz.ExaFELConfigBuilder_peakSize_get, _pysz.ExaFELConfigBuilder_peakSize_set)

    def free(params):
        """free(exafelSZ_params * params)"""
        return _pysz.ExaFELConfigBuilder_free(params)

    free = staticmethod(free)

    def setPeaks(self, peaks):
        """setPeaks(ExaFELConfigBuilder self, vectorui8 peaks)"""
        return _pysz.ExaFELConfigBuilder_setPeaks(self, peaks)


    def setCalibPanel(self, calibPanel):
        """setCalibPanel(ExaFELConfigBuilder self, vectorui8 calibPanel)"""
        return _pysz.ExaFELConfigBuilder_setCalibPanel(self, calibPanel)


    def __init__(self):
        """__init__(ExaFELConfigBuilder self) -> ExaFELConfigBuilder"""
        this = _pysz.new_ExaFELConfigBuilder()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pysz.delete_ExaFELConfigBuilder
    __del__ = lambda self: None
ExaFELConfigBuilder_swigregister = _pysz.ExaFELConfigBuilder_swigregister
ExaFELConfigBuilder_swigregister(ExaFELConfigBuilder)

def ExaFELConfigBuilder_free(params):
    """ExaFELConfigBuilder_free(exafelSZ_params * params)"""
    return _pysz.ExaFELConfigBuilder_free(params)

class Compressor(_object):
    """Proxy of C++ Compressor class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Compressor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Compressor, name)
    __repr__ = _swig_repr

    def __init__(self, config):
        """__init__(Compressor self, Config config) -> Compressor"""
        this = _pysz.new_Compressor(config)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _pysz.delete_Compressor
    __del__ = lambda self: None

    def CompressFloat1(self, data, params=None):
        """
        CompressFloat1(Compressor self, float * data, void * params=None) -> std::string
        CompressFloat1(Compressor self, float * data) -> std::string
        """
        return _pysz.Compressor_CompressFloat1(self, data, params)


    def CompressFloat2(self, data, params=None):
        """
        CompressFloat2(Compressor self, float * data, void * params=None) -> std::string
        CompressFloat2(Compressor self, float * data) -> std::string
        """
        return _pysz.Compressor_CompressFloat2(self, data, params)


    def CompressFloat3(self, data, params=None):
        """
        CompressFloat3(Compressor self, float * data, void * params=None) -> std::string
        CompressFloat3(Compressor self, float * data) -> std::string
        """
        return _pysz.Compressor_CompressFloat3(self, data, params)


    def CompressFloat4(self, data, params=None):
        """
        CompressFloat4(Compressor self, float * data, void * params=None) -> std::string
        CompressFloat4(Compressor self, float * data) -> std::string
        """
        return _pysz.Compressor_CompressFloat4(self, data, params)


    def CompressDouble1(self, data, params=None):
        """
        CompressDouble1(Compressor self, double * data, void * params=None) -> std::string
        CompressDouble1(Compressor self, double * data) -> std::string
        """
        return _pysz.Compressor_CompressDouble1(self, data, params)


    def CompressDouble2(self, data, params=None):
        """
        CompressDouble2(Compressor self, double * data, void * params=None) -> std::string
        CompressDouble2(Compressor self, double * data) -> std::string
        """
        return _pysz.Compressor_CompressDouble2(self, data, params)


    def CompressDouble3(self, data, params=None):
        """
        CompressDouble3(Compressor self, double * data, void * params=None) -> std::string
        CompressDouble3(Compressor self, double * data) -> std::string
        """
        return _pysz.Compressor_CompressDouble3(self, data, params)


    def CompressDouble4(self, data, params=None):
        """
        CompressDouble4(Compressor self, double * data, void * params=None) -> std::string
        CompressDouble4(Compressor self, double * data) -> std::string
        """
        return _pysz.Compressor_CompressDouble4(self, data, params)


    def CompressUInt8_1(self, data, params=None):
        """
        CompressUInt8_1(Compressor self, uint8_t * data, void * params=None) -> std::string
        CompressUInt8_1(Compressor self, uint8_t * data) -> std::string
        """
        return _pysz.Compressor_CompressUInt8_1(self, data, params)


    def CompressUInt8_2(self, data, params=None):
        """
        CompressUInt8_2(Compressor self, uint8_t * data, void * params=None) -> std::string
        CompressUInt8_2(Compressor self, uint8_t * data) -> std::string
        """
        return _pysz.Compressor_CompressUInt8_2(self, data, params)


    def CompressUInt8_3(self, data, params=None):
        """
        CompressUInt8_3(Compressor self, uint8_t * data, void * params=None) -> std::string
        CompressUInt8_3(Compressor self, uint8_t * data) -> std::string
        """
        return _pysz.Compressor_CompressUInt8_3(self, data, params)


    def CompressUInt8_4(self, data, params=None):
        """
        CompressUInt8_4(Compressor self, uint8_t * data, void * params=None) -> std::string
        CompressUInt8_4(Compressor self, uint8_t * data) -> std::string
        """
        return _pysz.Compressor_CompressUInt8_4(self, data, params)


    def CompressInt8_1(self, data, params=None):
        """
        CompressInt8_1(Compressor self, int8_t * data, void * params=None) -> std::string
        CompressInt8_1(Compressor self, int8_t * data) -> std::string
        """
        return _pysz.Compressor_CompressInt8_1(self, data, params)


    def CompressInt8_2(self, data, params=None):
        """
        CompressInt8_2(Compressor self, int8_t * data, void * params=None) -> std::string
        CompressInt8_2(Compressor self, int8_t * data) -> std::string
        """
        return _pysz.Compressor_CompressInt8_2(self, data, params)


    def CompressInt8_3(self, data, params=None):
        """
        CompressInt8_3(Compressor self, int8_t * data, void * params=None) -> std::string
        CompressInt8_3(Compressor self, int8_t * data) -> std::string
        """
        return _pysz.Compressor_CompressInt8_3(self, data, params)


    def CompressInt8_4(self, data, params=None):
        """
        CompressInt8_4(Compressor self, int8_t * data, void * params=None) -> std::string
        CompressInt8_4(Compressor self, int8_t * data) -> std::string
        """
        return _pysz.Compressor_CompressInt8_4(self, data, params)


    def CompressUInt16_1(self, data, params=None):
        """
        CompressUInt16_1(Compressor self, uint16_t * data, void * params=None) -> std::string
        CompressUInt16_1(Compressor self, uint16_t * data) -> std::string
        """
        return _pysz.Compressor_CompressUInt16_1(self, data, params)


    def CompressUInt16_2(self, data, params=None):
        """
        CompressUInt16_2(Compressor self, uint16_t * data, void * params=None) -> std::string
        CompressUInt16_2(Compressor self, uint16_t * data) -> std::string
        """
        return _pysz.Compressor_CompressUInt16_2(self, data, params)


    def CompressUInt16_3(self, data, params=None):
        """
        CompressUInt16_3(Compressor self, uint16_t * data, void * params=None) -> std::string
        CompressUInt16_3(Compressor self, uint16_t * data) -> std::string
        """
        return _pysz.Compressor_CompressUInt16_3(self, data, params)


    def CompressUInt16_4(self, data, params=None):
        """
        CompressUInt16_4(Compressor self, uint16_t * data, void * params=None) -> std::string
        CompressUInt16_4(Compressor self, uint16_t * data) -> std::string
        """
        return _pysz.Compressor_CompressUInt16_4(self, data, params)


    def CompressInt16_1(self, data, params=None):
        """
        CompressInt16_1(Compressor self, int16_t * data, void * params=None) -> std::string
        CompressInt16_1(Compressor self, int16_t * data) -> std::string
        """
        return _pysz.Compressor_CompressInt16_1(self, data, params)


    def CompressInt16_2(self, data, params=None):
        """
        CompressInt16_2(Compressor self, int16_t * data, void * params=None) -> std::string
        CompressInt16_2(Compressor self, int16_t * data) -> std::string
        """
        return _pysz.Compressor_CompressInt16_2(self, data, params)


    def CompressInt16_3(self, data, params=None):
        """
        CompressInt16_3(Compressor self, int16_t * data, void * params=None) -> std::string
        CompressInt16_3(Compressor self, int16_t * data) -> std::string
        """
        return _pysz.Compressor_CompressInt16_3(self, data, params)


    def CompressInt16_4(self, data, params=None):
        """
        CompressInt16_4(Compressor self, int16_t * data, void * params=None) -> std::string
        CompressInt16_4(Compressor self, int16_t * data) -> std::string
        """
        return _pysz.Compressor_CompressInt16_4(self, data, params)


    def CompressUInt32_1(self, data, params=None):
        """
        CompressUInt32_1(Compressor self, uint32_t * data, void * params=None) -> std::string
        CompressUInt32_1(Compressor self, uint32_t * data) -> std::string
        """
        return _pysz.Compressor_CompressUInt32_1(self, data, params)


    def CompressUInt32_2(self, data, params=None):
        """
        CompressUInt32_2(Compressor self, uint32_t * data, void * params=None) -> std::string
        CompressUInt32_2(Compressor self, uint32_t * data) -> std::string
        """
        return _pysz.Compressor_CompressUInt32_2(self, data, params)


    def CompressUInt32_3(self, data, params=None):
        """
        CompressUInt32_3(Compressor self, uint32_t * data, void * params=None) -> std::string
        CompressUInt32_3(Compressor self, uint32_t * data) -> std::string
        """
        return _pysz.Compressor_CompressUInt32_3(self, data, params)


    def CompressUInt32_4(self, data, params=None):
        """
        CompressUInt32_4(Compressor self, uint32_t * data, void * params=None) -> std::string
        CompressUInt32_4(Compressor self, uint32_t * data) -> std::string
        """
        return _pysz.Compressor_CompressUInt32_4(self, data, params)


    def CompressInt32_1(self, data, params=None):
        """
        CompressInt32_1(Compressor self, int32_t * data, void * params=None) -> std::string
        CompressInt32_1(Compressor self, int32_t * data) -> std::string
        """
        return _pysz.Compressor_CompressInt32_1(self, data, params)


    def CompressInt32_2(self, data, params=None):
        """
        CompressInt32_2(Compressor self, int32_t * data, void * params=None) -> std::string
        CompressInt32_2(Compressor self, int32_t * data) -> std::string
        """
        return _pysz.Compressor_CompressInt32_2(self, data, params)


    def CompressInt32_3(self, data, params=None):
        """
        CompressInt32_3(Compressor self, int32_t * data, void * params=None) -> std::string
        CompressInt32_3(Compressor self, int32_t * data) -> std::string
        """
        return _pysz.Compressor_CompressInt32_3(self, data, params)


    def CompressInt32_4(self, data, params=None):
        """
        CompressInt32_4(Compressor self, int32_t * data, void * params=None) -> std::string
        CompressInt32_4(Compressor self, int32_t * data) -> std::string
        """
        return _pysz.Compressor_CompressInt32_4(self, data, params)


    def CompressUInt64_1(self, data, params=None):
        """
        CompressUInt64_1(Compressor self, uint64_t * data, void * params=None) -> std::string
        CompressUInt64_1(Compressor self, uint64_t * data) -> std::string
        """
        return _pysz.Compressor_CompressUInt64_1(self, data, params)


    def CompressUInt64_2(self, data, params=None):
        """
        CompressUInt64_2(Compressor self, uint64_t * data, void * params=None) -> std::string
        CompressUInt64_2(Compressor self, uint64_t * data) -> std::string
        """
        return _pysz.Compressor_CompressUInt64_2(self, data, params)


    def CompressUInt64_3(self, data, params=None):
        """
        CompressUInt64_3(Compressor self, uint64_t * data, void * params=None) -> std::string
        CompressUInt64_3(Compressor self, uint64_t * data) -> std::string
        """
        return _pysz.Compressor_CompressUInt64_3(self, data, params)


    def CompressUInt64_4(self, data, params=None):
        """
        CompressUInt64_4(Compressor self, uint64_t * data, void * params=None) -> std::string
        CompressUInt64_4(Compressor self, uint64_t * data) -> std::string
        """
        return _pysz.Compressor_CompressUInt64_4(self, data, params)


    def CompressInt64_1(self, data, params=None):
        """
        CompressInt64_1(Compressor self, int64_t * data, void * params=None) -> std::string
        CompressInt64_1(Compressor self, int64_t * data) -> std::string
        """
        return _pysz.Compressor_CompressInt64_1(self, data, params)


    def CompressInt64_2(self, data, params=None):
        """
        CompressInt64_2(Compressor self, int64_t * data, void * params=None) -> std::string
        CompressInt64_2(Compressor self, int64_t * data) -> std::string
        """
        return _pysz.Compressor_CompressInt64_2(self, data, params)


    def CompressInt64_3(self, data, params=None):
        """
        CompressInt64_3(Compressor self, int64_t * data, void * params=None) -> std::string
        CompressInt64_3(Compressor self, int64_t * data) -> std::string
        """
        return _pysz.Compressor_CompressInt64_3(self, data, params)


    def CompressInt64_4(self, data, params=None):
        """
        CompressInt64_4(Compressor self, int64_t * data, void * params=None) -> std::string
        CompressInt64_4(Compressor self, int64_t * data) -> std::string
        """
        return _pysz.Compressor_CompressInt64_4(self, data, params)


    def DecompressFloat(self, data, r, params=None):
        """
        DecompressFloat(Compressor self, std::string data, vectori32 r, void * params=None) -> vectorf
        DecompressFloat(Compressor self, std::string data, vectori32 r) -> vectorf
        """
        return _pysz.Compressor_DecompressFloat(self, data, r, params)


    def DecompressDouble(self, data, r, params=None):
        """
        DecompressDouble(Compressor self, std::string data, vectori32 r, void * params=None) -> vectord
        DecompressDouble(Compressor self, std::string data, vectori32 r) -> vectord
        """
        return _pysz.Compressor_DecompressDouble(self, data, r, params)


    def DecompressUInt8(self, data, r, params=None):
        """
        DecompressUInt8(Compressor self, std::string data, vectori32 r, void * params=None) -> vectorui8
        DecompressUInt8(Compressor self, std::string data, vectori32 r) -> vectorui8
        """
        return _pysz.Compressor_DecompressUInt8(self, data, r, params)


    def DecompressInt8(self, data, r, params=None):
        """
        DecompressInt8(Compressor self, std::string data, vectori32 r, void * params=None) -> vectori8
        DecompressInt8(Compressor self, std::string data, vectori32 r) -> vectori8
        """
        return _pysz.Compressor_DecompressInt8(self, data, r, params)


    def DecompressUInt16(self, data, r, params=None):
        """
        DecompressUInt16(Compressor self, std::string data, vectori32 r, void * params=None) -> vectorui16
        DecompressUInt16(Compressor self, std::string data, vectori32 r) -> vectorui16
        """
        return _pysz.Compressor_DecompressUInt16(self, data, r, params)


    def DecompressInt16(self, data, r, params=None):
        """
        DecompressInt16(Compressor self, std::string data, vectori32 r, void * params=None) -> vectori16
        DecompressInt16(Compressor self, std::string data, vectori32 r) -> vectori16
        """
        return _pysz.Compressor_DecompressInt16(self, data, r, params)


    def DecompressUInt32(self, data, r, params=None):
        """
        DecompressUInt32(Compressor self, std::string data, vectori32 r, void * params=None) -> vectorui32
        DecompressUInt32(Compressor self, std::string data, vectori32 r) -> vectorui32
        """
        return _pysz.Compressor_DecompressUInt32(self, data, r, params)


    def DecompressInt32(self, data, r, params=None):
        """
        DecompressInt32(Compressor self, std::string data, vectori32 r, void * params=None) -> std::vector< int32_t,std::allocator< int32_t > >
        DecompressInt32(Compressor self, std::string data, vectori32 r) -> std::vector< int32_t,std::allocator< int32_t > >
        """
        return _pysz.Compressor_DecompressInt32(self, data, r, params)


    def DecompressUInt64(self, data, r, params=None):
        """
        DecompressUInt64(Compressor self, std::string data, vectori32 r, void * params=None) -> vectorui64
        DecompressUInt64(Compressor self, std::string data, vectori32 r) -> vectorui64
        """
        return _pysz.Compressor_DecompressUInt64(self, data, r, params)


    def DecompressInt64(self, data, r, params=None):
        """
        DecompressInt64(Compressor self, std::string data, vectori32 r, void * params=None) -> vectori64
        DecompressInt64(Compressor self, std::string data, vectori32 r) -> vectori64
        """
        return _pysz.Compressor_DecompressInt64(self, data, r, params)


    import numpy

    __Compress = {
      (1, numpy.dtype('float64')): CompressDouble1,
      (2, numpy.dtype('float64')): CompressDouble2,
      (3, numpy.dtype('float64')): CompressDouble3,
      (4, numpy.dtype('float64')): CompressDouble4,
      (1, numpy.dtype('float32')): CompressFloat1,
      (2, numpy.dtype('float32')): CompressFloat2,
      (3, numpy.dtype('float32')): CompressFloat3,
      (4, numpy.dtype('float32')): CompressFloat4,
      (1, numpy.dtype('uint8')): CompressUInt8_1,
      (2, numpy.dtype('uint8')): CompressUInt8_2,
      (3, numpy.dtype('uint8')): CompressUInt8_3,
      (4, numpy.dtype('uint8')): CompressUInt8_4,
      (1, numpy.dtype('int8')): CompressInt8_1,
      (2, numpy.dtype('int8')): CompressInt8_2,
      (3, numpy.dtype('int8')): CompressInt8_3,
      (4, numpy.dtype('int8')): CompressInt8_4,
      (1, numpy.dtype('uint16')): CompressUInt16_1,
      (2, numpy.dtype('uint16')): CompressUInt16_2,
      (3, numpy.dtype('uint16')): CompressUInt16_3,
      (4, numpy.dtype('uint16')): CompressUInt16_4,
      (1, numpy.dtype('int16')): CompressInt16_1,
      (2, numpy.dtype('int16')): CompressInt16_2,
      (3, numpy.dtype('int16')): CompressInt16_3,
      (4, numpy.dtype('int16')): CompressInt16_4,
      (1, numpy.dtype('uint32')): CompressUInt32_1,
      (2, numpy.dtype('uint32')): CompressUInt32_2,
      (3, numpy.dtype('uint32')): CompressUInt32_3,
      (4, numpy.dtype('uint32')): CompressUInt32_4,
      (1, numpy.dtype('int32')): CompressInt32_1,
      (2, numpy.dtype('int32')): CompressInt32_2,
      (3, numpy.dtype('int32')): CompressInt32_3,
      (4, numpy.dtype('int32')): CompressInt32_4,
      (1, numpy.dtype('uint64')): CompressUInt64_1,
      (2, numpy.dtype('uint64')): CompressUInt64_2,
      (3, numpy.dtype('uint64')): CompressUInt64_3,
      (4, numpy.dtype('uint64')): CompressUInt64_4,
      (1, numpy.dtype('int64')): CompressInt64_1,
      (2, numpy.dtype('int64')): CompressInt64_2,
      (3, numpy.dtype('int64')): CompressInt64_3,
      (4, numpy.dtype('int64')): CompressInt64_4,
    }

    __Decompress = {
      numpy.dtype('float32'): DecompressFloat,
      numpy.float32: DecompressFloat,

      numpy.dtype('float64'): DecompressDouble,
      numpy.float64: DecompressDouble,

      numpy.dtype('uint8'): DecompressUInt8,
      numpy.uint8: DecompressUInt8,
      numpy.dtype('int8'): DecompressInt8,
      numpy.int8: DecompressInt8,

      numpy.dtype('uint16'): DecompressUInt16,
      numpy.uint16: DecompressUInt16,
      numpy.dtype('int16'): DecompressInt16,
      numpy.int16: DecompressInt16,

      numpy.dtype('uint32'): DecompressUInt32,
      numpy.uint32: DecompressUInt32,
      numpy.dtype('int32'): DecompressInt32,
      numpy.int32: DecompressInt32,

      numpy.dtype('uint64'): DecompressUInt64,
      numpy.uint64: DecompressUInt64,
      numpy.dtype('int64'): DecompressInt64,
      numpy.int64: DecompressInt64,
    }

    def Compress(self, array, userparams=None):
      length = len(array.shape)
      dtype = array.dtype
      return self.__Compress[length, dtype](self, array, userparams)

    def Decompress(self, bytes, dims, dtype, userparams=None):
      try:
        values = self.__Decompress[dtype](self, bytes, list(dims), userparams)
        return self.numpy.reshape(values, dims)
      except KeyError as e:
        raise TypeError("type {} not supported".format(i.args[0]))





Compressor_swigregister = _pysz.Compressor_swigregister
Compressor_swigregister(Compressor)

SZ_VERNUM = _pysz.SZ_VERNUM
SZ_VER_MAJOR = _pysz.SZ_VER_MAJOR
SZ_VER_MINOR = _pysz.SZ_VER_MINOR
SZ_VER_BUILD = _pysz.SZ_VER_BUILD
SZ_VER_REVISION = _pysz.SZ_VER_REVISION
PASTRI = _pysz.PASTRI
HZ = _pysz.HZ
SZ = _pysz.SZ
SZ_Transpose = _pysz.SZ_Transpose
SZ_PREVIOUS_VALUE_ESTIMATE = _pysz.SZ_PREVIOUS_VALUE_ESTIMATE
MIN_NUM_OF_ELEMENTS = _pysz.MIN_NUM_OF_ELEMENTS
ABS = _pysz.ABS
REL = _pysz.REL
VR_REL = _pysz.VR_REL
ABS_AND_REL = _pysz.ABS_AND_REL
ABS_OR_REL = _pysz.ABS_OR_REL
PSNR = _pysz.PSNR
NORM = _pysz.NORM
PW_REL = _pysz.PW_REL
ABS_AND_PW_REL = _pysz.ABS_AND_PW_REL
ABS_OR_PW_REL = _pysz.ABS_OR_PW_REL
REL_AND_PW_REL = _pysz.REL_AND_PW_REL
REL_OR_PW_REL = _pysz.REL_OR_PW_REL
SZ_FLOAT = _pysz.SZ_FLOAT
SZ_DOUBLE = _pysz.SZ_DOUBLE
SZ_UINT8 = _pysz.SZ_UINT8
SZ_INT8 = _pysz.SZ_INT8
SZ_UINT16 = _pysz.SZ_UINT16
SZ_INT16 = _pysz.SZ_INT16
SZ_UINT32 = _pysz.SZ_UINT32
SZ_INT32 = _pysz.SZ_INT32
SZ_UINT64 = _pysz.SZ_UINT64
SZ_INT64 = _pysz.SZ_INT64
LITTLE_ENDIAN_DATA = _pysz.LITTLE_ENDIAN_DATA
BIG_ENDIAN_DATA = _pysz.BIG_ENDIAN_DATA
LITTLE_ENDIAN_SYSTEM = _pysz.LITTLE_ENDIAN_SYSTEM
BIG_ENDIAN_SYSTEM = _pysz.BIG_ENDIAN_SYSTEM
DynArrayInitLen = _pysz.DynArrayInitLen
MIN_ZLIB_DEC_ALLOMEM_BYTES = _pysz.MIN_ZLIB_DEC_ALLOMEM_BYTES
SZ_BEST_SPEED = _pysz.SZ_BEST_SPEED
SZ_BEST_COMPRESSION = _pysz.SZ_BEST_COMPRESSION
SZ_DEFAULT_COMPRESSION = _pysz.SZ_DEFAULT_COMPRESSION
SZ_TEMPORAL_COMPRESSION = _pysz.SZ_TEMPORAL_COMPRESSION
SZ_NO_REGRESSION = _pysz.SZ_NO_REGRESSION
SZ_WITH_LINEAR_REGRESSION = _pysz.SZ_WITH_LINEAR_REGRESSION
SZ_PWR_MIN_TYPE = _pysz.SZ_PWR_MIN_TYPE
SZ_PWR_AVG_TYPE = _pysz.SZ_PWR_AVG_TYPE
SZ_PWR_MAX_TYPE = _pysz.SZ_PWR_MAX_TYPE
SZ_FORCE_SNAPSHOT_COMPRESSION = _pysz.SZ_FORCE_SNAPSHOT_COMPRESSION
SZ_FORCE_TEMPORAL_COMPRESSION = _pysz.SZ_FORCE_TEMPORAL_COMPRESSION
SZ_PERIO_TEMPORAL_COMPRESSION = _pysz.SZ_PERIO_TEMPORAL_COMPRESSION
SZ_SCES = _pysz.SZ_SCES
SZ_NSCS = _pysz.SZ_NSCS
SZ_FERR = _pysz.SZ_FERR
SZ_TERR = _pysz.SZ_TERR
SZ_DERR = _pysz.SZ_DERR
SZ_MERR = _pysz.SZ_MERR
SZ_BERR = _pysz.SZ_BERR
SZ_MAINTAIN_VAR_DATA = _pysz.SZ_MAINTAIN_VAR_DATA
SZ_DESTROY_WHOLE_VARSET = _pysz.SZ_DESTROY_WHOLE_VARSET
GROUP_COUNT = _pysz.GROUP_COUNT
MetaDataByteLength = _pysz.MetaDataByteLength
MetaDataByteLength_double = _pysz.MetaDataByteLength_double
numOfBufferedSteps = _pysz.numOfBufferedSteps
GZIP_COMPRESSOR = _pysz.GZIP_COMPRESSOR
ZSTD_COMPRESSOR = _pysz.ZSTD_COMPRESSOR
# This file is compatible with both classic and new-style classes.


