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

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

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __sub__(self, *args):
        r"""
        __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

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

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

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

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

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

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

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

    def __getslice__(self, i, j):
        r"""__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):
        r"""
        __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):
        r"""__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):
        r"""
        __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):
        r"""
        __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):
        r"""
        __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):
        r"""pop(vectori8 self) -> std::vector< int8_t >::value_type"""
        return _pysz.vectori8_pop(self)

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

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

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

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

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

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

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

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

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

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

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

    def erase(self, *args):
        r"""
        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):
        r"""
        __init__(vectori8 self) -> vectori8
        __init__(vectori8 self, vectori8 other) -> vectori8
        __init__(vectori8 self, std::vector< int8_t >::size_type size) -> vectori8
        __init__(vectori8 self, std::vector< int8_t >::size_type size, std::vector< int8_t >::value_type const & value) -> vectori8
        """
        _pysz.vectori8_swiginit(self, _pysz.new_vectori8(*args))

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

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

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

    def assign(self, n, x):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""reserve(vectori8 self, std::vector< int8_t >::size_type n)"""
        return _pysz.vectori8_reserve(self, n)

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

# Register vectori8 in _pysz:
_pysz.vectori8_swigregister(vectori8)

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

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

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

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

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

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

    def __getslice__(self, i, j):
        r"""__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):
        r"""
        __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):
        r"""__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):
        r"""
        __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):
        r"""
        __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):
        r"""
        __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):
        r"""pop(vectori16 self) -> std::vector< int16_t >::value_type"""
        return _pysz.vectori16_pop(self)

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

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

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

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

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

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

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

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

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

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

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

    def erase(self, *args):
        r"""
        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):
        r"""
        __init__(vectori16 self) -> vectori16
        __init__(vectori16 self, vectori16 other) -> vectori16
        __init__(vectori16 self, std::vector< int16_t >::size_type size) -> vectori16
        __init__(vectori16 self, std::vector< int16_t >::size_type size, std::vector< int16_t >::value_type const & value) -> vectori16
        """
        _pysz.vectori16_swiginit(self, _pysz.new_vectori16(*args))

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

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

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

    def assign(self, n, x):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""reserve(vectori16 self, std::vector< int16_t >::size_type n)"""
        return _pysz.vectori16_reserve(self, n)

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

# Register vectori16 in _pysz:
_pysz.vectori16_swigregister(vectori16)

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

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

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

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

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

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

    def __getslice__(self, i, j):
        r"""__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):
        r"""
        __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):
        r"""__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):
        r"""
        __delitem__(vectori32 self, std::vector< int >::difference_type i)
        __delitem__(vectori32 self, PySliceObject * slice)
        """
        return _pysz.vectori32___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __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):
        r"""
        __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):
        r"""pop(vectori32 self) -> std::vector< int >::value_type"""
        return _pysz.vectori32_pop(self)

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

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

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

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

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

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

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

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

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

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

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

    def erase(self, *args):
        r"""
        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):
        r"""
        __init__(vectori32 self) -> vectori32
        __init__(vectori32 self, vectori32 other) -> vectori32
        __init__(vectori32 self, std::vector< int >::size_type size) -> vectori32
        __init__(vectori32 self, std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> vectori32
        """
        _pysz.vectori32_swiginit(self, _pysz.new_vectori32(*args))

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

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

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

    def assign(self, n, x):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""reserve(vectori32 self, std::vector< int >::size_type n)"""
        return _pysz.vectori32_reserve(self, n)

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

# Register vectori32 in _pysz:
_pysz.vectori32_swigregister(vectori32)

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

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

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

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

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

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

    def __getslice__(self, i, j):
        r"""__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):
        r"""
        __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):
        r"""__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):
        r"""
        __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):
        r"""
        __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):
        r"""
        __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):
        r"""pop(vectori64 self) -> std::vector< int64_t >::value_type"""
        return _pysz.vectori64_pop(self)

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

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

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

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

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

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

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

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

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

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

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

    def erase(self, *args):
        r"""
        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):
        r"""
        __init__(vectori64 self) -> vectori64
        __init__(vectori64 self, vectori64 other) -> vectori64
        __init__(vectori64 self, std::vector< int64_t >::size_type size) -> vectori64
        __init__(vectori64 self, std::vector< int64_t >::size_type size, std::vector< int64_t >::value_type const & value) -> vectori64
        """
        _pysz.vectori64_swiginit(self, _pysz.new_vectori64(*args))

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

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

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

    def assign(self, n, x):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""reserve(vectori64 self, std::vector< int64_t >::size_type n)"""
        return _pysz.vectori64_reserve(self, n)

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

# Register vectori64 in _pysz:
_pysz.vectori64_swigregister(vectori64)

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

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

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

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

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

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

    def __getslice__(self, i, j):
        r"""__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):
        r"""
        __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):
        r"""__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):
        r"""
        __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):
        r"""
        __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):
        r"""
        __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):
        r"""pop(vectorui8 self) -> std::vector< uint8_t >::value_type"""
        return _pysz.vectorui8_pop(self)

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

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

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

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

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

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

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

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

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

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

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

    def erase(self, *args):
        r"""
        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):
        r"""
        __init__(vectorui8 self) -> vectorui8
        __init__(vectorui8 self, vectorui8 other) -> vectorui8
        __init__(vectorui8 self, std::vector< uint8_t >::size_type size) -> vectorui8
        __init__(vectorui8 self, std::vector< uint8_t >::size_type size, std::vector< uint8_t >::value_type const & value) -> vectorui8
        """
        _pysz.vectorui8_swiginit(self, _pysz.new_vectorui8(*args))

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

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

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

    def assign(self, n, x):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""reserve(vectorui8 self, std::vector< uint8_t >::size_type n)"""
        return _pysz.vectorui8_reserve(self, n)

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

# Register vectorui8 in _pysz:
_pysz.vectorui8_swigregister(vectorui8)

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

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

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

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

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

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

    def __getslice__(self, i, j):
        r"""__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):
        r"""
        __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):
        r"""__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):
        r"""
        __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):
        r"""
        __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):
        r"""
        __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):
        r"""pop(vectorui16 self) -> std::vector< uint16_t >::value_type"""
        return _pysz.vectorui16_pop(self)

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

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

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

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

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

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

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

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

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

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

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

    def erase(self, *args):
        r"""
        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):
        r"""
        __init__(vectorui16 self) -> vectorui16
        __init__(vectorui16 self, vectorui16 other) -> vectorui16
        __init__(vectorui16 self, std::vector< uint16_t >::size_type size) -> vectorui16
        __init__(vectorui16 self, std::vector< uint16_t >::size_type size, std::vector< uint16_t >::value_type const & value) -> vectorui16
        """
        _pysz.vectorui16_swiginit(self, _pysz.new_vectorui16(*args))

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

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

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

    def assign(self, n, x):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""reserve(vectorui16 self, std::vector< uint16_t >::size_type n)"""
        return _pysz.vectorui16_reserve(self, n)

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

# Register vectorui16 in _pysz:
_pysz.vectorui16_swigregister(vectorui16)

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

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

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

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

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

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

    def __getslice__(self, i, j):
        r"""__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):
        r"""
        __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):
        r"""__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):
        r"""
        __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):
        r"""
        __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):
        r"""
        __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):
        r"""pop(vectorui32 self) -> std::vector< uint32_t >::value_type"""
        return _pysz.vectorui32_pop(self)

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

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

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

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

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

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

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

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

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

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

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

    def erase(self, *args):
        r"""
        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):
        r"""
        __init__(vectorui32 self) -> vectorui32
        __init__(vectorui32 self, vectorui32 other) -> vectorui32
        __init__(vectorui32 self, std::vector< uint32_t >::size_type size) -> vectorui32
        __init__(vectorui32 self, std::vector< uint32_t >::size_type size, std::vector< uint32_t >::value_type const & value) -> vectorui32
        """
        _pysz.vectorui32_swiginit(self, _pysz.new_vectorui32(*args))

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

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

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

    def assign(self, n, x):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""reserve(vectorui32 self, std::vector< uint32_t >::size_type n)"""
        return _pysz.vectorui32_reserve(self, n)

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

# Register vectorui32 in _pysz:
_pysz.vectorui32_swigregister(vectorui32)

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

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

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

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

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

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

    def __getslice__(self, i, j):
        r"""__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):
        r"""
        __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):
        r"""__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):
        r"""
        __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):
        r"""
        __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):
        r"""
        __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):
        r"""pop(vectorui64 self) -> std::vector< uint64_t >::value_type"""
        return _pysz.vectorui64_pop(self)

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

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

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

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

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

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

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

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

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

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

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

    def erase(self, *args):
        r"""
        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):
        r"""
        __init__(vectorui64 self) -> vectorui64
        __init__(vectorui64 self, vectorui64 other) -> vectorui64
        __init__(vectorui64 self, std::vector< uint64_t >::size_type size) -> vectorui64
        __init__(vectorui64 self, std::vector< uint64_t >::size_type size, std::vector< uint64_t >::value_type const & value) -> vectorui64
        """
        _pysz.vectorui64_swiginit(self, _pysz.new_vectorui64(*args))

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

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

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

    def assign(self, n, x):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""reserve(vectorui64 self, std::vector< uint64_t >::size_type n)"""
        return _pysz.vectorui64_reserve(self, n)

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

# Register vectorui64 in _pysz:
_pysz.vectorui64_swigregister(vectorui64)

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

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

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

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

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

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

    def __getslice__(self, i, j):
        r"""__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):
        r"""
        __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):
        r"""__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):
        r"""
        __delitem__(vectorf self, std::vector< float >::difference_type i)
        __delitem__(vectorf self, PySliceObject * slice)
        """
        return _pysz.vectorf___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __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):
        r"""
        __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):
        r"""pop(vectorf self) -> std::vector< float >::value_type"""
        return _pysz.vectorf_pop(self)

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

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

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

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

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

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

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

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

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

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

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

    def erase(self, *args):
        r"""
        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):
        r"""
        __init__(vectorf self) -> vectorf
        __init__(vectorf self, vectorf other) -> vectorf
        __init__(vectorf self, std::vector< float >::size_type size) -> vectorf
        __init__(vectorf self, std::vector< float >::size_type size, std::vector< float >::value_type const & value) -> vectorf
        """
        _pysz.vectorf_swiginit(self, _pysz.new_vectorf(*args))

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

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

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

    def assign(self, n, x):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""reserve(vectorf self, std::vector< float >::size_type n)"""
        return _pysz.vectorf_reserve(self, n)

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

# Register vectorf in _pysz:
_pysz.vectorf_swigregister(vectorf)

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

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

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

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

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

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

    def __getslice__(self, i, j):
        r"""__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):
        r"""
        __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):
        r"""__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):
        r"""
        __delitem__(vectord self, std::vector< double >::difference_type i)
        __delitem__(vectord self, PySliceObject * slice)
        """
        return _pysz.vectord___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __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):
        r"""
        __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):
        r"""pop(vectord self) -> std::vector< double >::value_type"""
        return _pysz.vectord_pop(self)

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

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

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

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

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

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

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

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

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

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

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

    def erase(self, *args):
        r"""
        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):
        r"""
        __init__(vectord self) -> vectord
        __init__(vectord self, vectord other) -> vectord
        __init__(vectord self, std::vector< double >::size_type size) -> vectord
        __init__(vectord self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> vectord
        """
        _pysz.vectord_swiginit(self, _pysz.new_vectord(*args))

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

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

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

    def assign(self, n, x):
        r"""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):
        r"""
        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):
        r"""
        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):
        r"""reserve(vectord self, std::vector< double >::size_type n)"""
        return _pysz.vectord_reserve(self, n)

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

# Register vectord in _pysz:
_pysz.vectord_swigregister(vectord)

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

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    params = property(_pysz.Config_params_get, _pysz.Config_params_set, doc=r"""params : sz_params""")
    app = property(_pysz.Config_app_get, _pysz.Config_app_set, doc=r"""app : std::string""")

    def __init__(self):
        r"""__init__(Config self) -> Config"""
        _pysz.Config_swiginit(self, _pysz.new_Config())
    __swig_destroy__ = _pysz.delete_Config

# Register Config in _pysz:
_pysz.Config_swigregister(Config)

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

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

    def __init__(self, *args):
        r"""
        __init__(ConfigBuilder self) -> ConfigBuilder
        __init__(ConfigBuilder self, std::string const & config_file_path) -> ConfigBuilder
        """
        _pysz.ConfigBuilder_swiginit(self, _pysz.new_ConfigBuilder(*args))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register ConfigBuilder in _pysz:
_pysz.ConfigBuilder_swigregister(ConfigBuilder)

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

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

    def build(self):
        r"""build(ExaFELConfigBuilder self) -> exafelSZ_params *"""
        return _pysz.ExaFELConfigBuilder_build(self)
    binSize = property(_pysz.ExaFELConfigBuilder_binSize_get, _pysz.ExaFELConfigBuilder_binSize_set, doc=r"""binSize : int""")
    tolerance = property(_pysz.ExaFELConfigBuilder_tolerance_get, _pysz.ExaFELConfigBuilder_tolerance_set, doc=r"""tolerance : double""")
    szDim = property(_pysz.ExaFELConfigBuilder_szDim_get, _pysz.ExaFELConfigBuilder_szDim_set, doc=r"""szDim : int""")
    peakSize = property(_pysz.ExaFELConfigBuilder_peakSize_get, _pysz.ExaFELConfigBuilder_peakSize_set, doc=r"""peakSize : int""")

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

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

    def setPeaksRows(self, rows):
        r"""setPeaksRows(ExaFELConfigBuilder self, vectorui16 rows)"""
        return _pysz.ExaFELConfigBuilder_setPeaksRows(self, rows)

    def setPeaksCols(self, cols):
        r"""setPeaksCols(ExaFELConfigBuilder self, vectorui16 cols)"""
        return _pysz.ExaFELConfigBuilder_setPeaksCols(self, cols)

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

    def __init__(self):
        r"""__init__(ExaFELConfigBuilder self) -> ExaFELConfigBuilder"""
        _pysz.ExaFELConfigBuilder_swiginit(self, _pysz.new_ExaFELConfigBuilder())
    __swig_destroy__ = _pysz.delete_ExaFELConfigBuilder

# Register ExaFELConfigBuilder in _pysz:
_pysz.ExaFELConfigBuilder_swigregister(ExaFELConfigBuilder)

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

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

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

    def __init__(self, config):
        r"""__init__(Compressor self, Config config) -> Compressor"""
        _pysz.Compressor_swiginit(self, _pysz.new_Compressor(config))
    __swig_destroy__ = _pysz.delete_Compressor

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def DecompressInt64(self, data, r, params=None):
        r"""DecompressInt64(Compressor self, std::string data, vectori32 r, void * params=None) -> 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]))






# Register Compressor in _pysz:
_pysz.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



