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

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

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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

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

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

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

    def value(self):
        return _swig_decoders.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _swig_decoders.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _swig_decoders.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _swig_decoders.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _swig_decoders.SwigPyIterator_equal(self, x)

    def copy(self):
        return _swig_decoders.SwigPyIterator_copy(self)

    def next(self):
        return _swig_decoders.SwigPyIterator_next(self)

    def __next__(self):
        return _swig_decoders.SwigPyIterator___next__(self)

    def previous(self):
        return _swig_decoders.SwigPyIterator_previous(self)

    def advance(self, n):
        return _swig_decoders.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _swig_decoders.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _swig_decoders.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _swig_decoders.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _swig_decoders.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _swig_decoders.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _swig_decoders.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
SwigPyIterator_swigregister = _swig_decoders.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

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

    def __init__(self):
        this = _swig_decoders.new_PathTrie()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _swig_decoders.delete_PathTrie
    __del__ = lambda self: None

    def get_path_trie(self, new_char, reset=True):
        return _swig_decoders.PathTrie_get_path_trie(self, new_char, reset)

    def get_path_vec(self, *args):
        return _swig_decoders.PathTrie_get_path_vec(self, *args)

    def iterate_to_vec(self, output):
        return _swig_decoders.PathTrie_iterate_to_vec(self, output)

    def iterate_to_vec_only(self, output):
        return _swig_decoders.PathTrie_iterate_to_vec_only(self, output)

    def set_dictionary(self, dictionary):
        return _swig_decoders.PathTrie_set_dictionary(self, dictionary)

    def set_matcher(self, arg2):
        return _swig_decoders.PathTrie_set_matcher(self, arg2)

    def is_empty(self):
        return _swig_decoders.PathTrie_is_empty(self)

    def remove(self):
        return _swig_decoders.PathTrie_remove(self)
    __swig_setmethods__["log_prob_b_prev"] = _swig_decoders.PathTrie_log_prob_b_prev_set
    __swig_getmethods__["log_prob_b_prev"] = _swig_decoders.PathTrie_log_prob_b_prev_get
    if _newclass:
        log_prob_b_prev = _swig_property(_swig_decoders.PathTrie_log_prob_b_prev_get, _swig_decoders.PathTrie_log_prob_b_prev_set)
    __swig_setmethods__["log_prob_nb_prev"] = _swig_decoders.PathTrie_log_prob_nb_prev_set
    __swig_getmethods__["log_prob_nb_prev"] = _swig_decoders.PathTrie_log_prob_nb_prev_get
    if _newclass:
        log_prob_nb_prev = _swig_property(_swig_decoders.PathTrie_log_prob_nb_prev_get, _swig_decoders.PathTrie_log_prob_nb_prev_set)
    __swig_setmethods__["log_prob_b_cur"] = _swig_decoders.PathTrie_log_prob_b_cur_set
    __swig_getmethods__["log_prob_b_cur"] = _swig_decoders.PathTrie_log_prob_b_cur_get
    if _newclass:
        log_prob_b_cur = _swig_property(_swig_decoders.PathTrie_log_prob_b_cur_get, _swig_decoders.PathTrie_log_prob_b_cur_set)
    __swig_setmethods__["log_prob_nb_cur"] = _swig_decoders.PathTrie_log_prob_nb_cur_set
    __swig_getmethods__["log_prob_nb_cur"] = _swig_decoders.PathTrie_log_prob_nb_cur_get
    if _newclass:
        log_prob_nb_cur = _swig_property(_swig_decoders.PathTrie_log_prob_nb_cur_get, _swig_decoders.PathTrie_log_prob_nb_cur_set)
    __swig_setmethods__["score"] = _swig_decoders.PathTrie_score_set
    __swig_getmethods__["score"] = _swig_decoders.PathTrie_score_get
    if _newclass:
        score = _swig_property(_swig_decoders.PathTrie_score_get, _swig_decoders.PathTrie_score_set)
    __swig_setmethods__["approx_ctc"] = _swig_decoders.PathTrie_approx_ctc_set
    __swig_getmethods__["approx_ctc"] = _swig_decoders.PathTrie_approx_ctc_get
    if _newclass:
        approx_ctc = _swig_property(_swig_decoders.PathTrie_approx_ctc_get, _swig_decoders.PathTrie_approx_ctc_set)
    __swig_setmethods__["character"] = _swig_decoders.PathTrie_character_set
    __swig_getmethods__["character"] = _swig_decoders.PathTrie_character_get
    if _newclass:
        character = _swig_property(_swig_decoders.PathTrie_character_get, _swig_decoders.PathTrie_character_set)
    __swig_setmethods__["parent"] = _swig_decoders.PathTrie_parent_set
    __swig_getmethods__["parent"] = _swig_decoders.PathTrie_parent_get
    if _newclass:
        parent = _swig_property(_swig_decoders.PathTrie_parent_get, _swig_decoders.PathTrie_parent_set)
PathTrie_swigregister = _swig_decoders.PathTrie_swigregister
PathTrie_swigregister(PathTrie)

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

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

    def __nonzero__(self):
        return _swig_decoders.DoubleVector___nonzero__(self)

    def __bool__(self):
        return _swig_decoders.DoubleVector___bool__(self)

    def __len__(self):
        return _swig_decoders.DoubleVector___len__(self)

    def __getslice__(self, i, j):
        return _swig_decoders.DoubleVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _swig_decoders.DoubleVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _swig_decoders.DoubleVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _swig_decoders.DoubleVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _swig_decoders.DoubleVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _swig_decoders.DoubleVector___setitem__(self, *args)

    def pop(self):
        return _swig_decoders.DoubleVector_pop(self)

    def append(self, x):
        return _swig_decoders.DoubleVector_append(self, x)

    def empty(self):
        return _swig_decoders.DoubleVector_empty(self)

    def size(self):
        return _swig_decoders.DoubleVector_size(self)

    def swap(self, v):
        return _swig_decoders.DoubleVector_swap(self, v)

    def begin(self):
        return _swig_decoders.DoubleVector_begin(self)

    def end(self):
        return _swig_decoders.DoubleVector_end(self)

    def rbegin(self):
        return _swig_decoders.DoubleVector_rbegin(self)

    def rend(self):
        return _swig_decoders.DoubleVector_rend(self)

    def clear(self):
        return _swig_decoders.DoubleVector_clear(self)

    def get_allocator(self):
        return _swig_decoders.DoubleVector_get_allocator(self)

    def pop_back(self):
        return _swig_decoders.DoubleVector_pop_back(self)

    def erase(self, *args):
        return _swig_decoders.DoubleVector_erase(self, *args)

    def __init__(self, *args):
        this = _swig_decoders.new_DoubleVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _swig_decoders.DoubleVector_push_back(self, x)

    def front(self):
        return _swig_decoders.DoubleVector_front(self)

    def back(self):
        return _swig_decoders.DoubleVector_back(self)

    def assign(self, n, x):
        return _swig_decoders.DoubleVector_assign(self, n, x)

    def resize(self, *args):
        return _swig_decoders.DoubleVector_resize(self, *args)

    def insert(self, *args):
        return _swig_decoders.DoubleVector_insert(self, *args)

    def reserve(self, n):
        return _swig_decoders.DoubleVector_reserve(self, n)

    def capacity(self):
        return _swig_decoders.DoubleVector_capacity(self)
    __swig_destroy__ = _swig_decoders.delete_DoubleVector
    __del__ = lambda self: None
DoubleVector_swigregister = _swig_decoders.DoubleVector_swigregister
DoubleVector_swigregister(DoubleVector)

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

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

    def __nonzero__(self):
        return _swig_decoders.IntVector___nonzero__(self)

    def __bool__(self):
        return _swig_decoders.IntVector___bool__(self)

    def __len__(self):
        return _swig_decoders.IntVector___len__(self)

    def __getslice__(self, i, j):
        return _swig_decoders.IntVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _swig_decoders.IntVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _swig_decoders.IntVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _swig_decoders.IntVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _swig_decoders.IntVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _swig_decoders.IntVector___setitem__(self, *args)

    def pop(self):
        return _swig_decoders.IntVector_pop(self)

    def append(self, x):
        return _swig_decoders.IntVector_append(self, x)

    def empty(self):
        return _swig_decoders.IntVector_empty(self)

    def size(self):
        return _swig_decoders.IntVector_size(self)

    def swap(self, v):
        return _swig_decoders.IntVector_swap(self, v)

    def begin(self):
        return _swig_decoders.IntVector_begin(self)

    def end(self):
        return _swig_decoders.IntVector_end(self)

    def rbegin(self):
        return _swig_decoders.IntVector_rbegin(self)

    def rend(self):
        return _swig_decoders.IntVector_rend(self)

    def clear(self):
        return _swig_decoders.IntVector_clear(self)

    def get_allocator(self):
        return _swig_decoders.IntVector_get_allocator(self)

    def pop_back(self):
        return _swig_decoders.IntVector_pop_back(self)

    def erase(self, *args):
        return _swig_decoders.IntVector_erase(self, *args)

    def __init__(self, *args):
        this = _swig_decoders.new_IntVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _swig_decoders.IntVector_push_back(self, x)

    def front(self):
        return _swig_decoders.IntVector_front(self)

    def back(self):
        return _swig_decoders.IntVector_back(self)

    def assign(self, n, x):
        return _swig_decoders.IntVector_assign(self, n, x)

    def resize(self, *args):
        return _swig_decoders.IntVector_resize(self, *args)

    def insert(self, *args):
        return _swig_decoders.IntVector_insert(self, *args)

    def reserve(self, n):
        return _swig_decoders.IntVector_reserve(self, n)

    def capacity(self):
        return _swig_decoders.IntVector_capacity(self)
    __swig_destroy__ = _swig_decoders.delete_IntVector
    __del__ = lambda self: None
IntVector_swigregister = _swig_decoders.IntVector_swigregister
IntVector_swigregister(IntVector)

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

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

    def __nonzero__(self):
        return _swig_decoders.StringVector___nonzero__(self)

    def __bool__(self):
        return _swig_decoders.StringVector___bool__(self)

    def __len__(self):
        return _swig_decoders.StringVector___len__(self)

    def __getslice__(self, i, j):
        return _swig_decoders.StringVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _swig_decoders.StringVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _swig_decoders.StringVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _swig_decoders.StringVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _swig_decoders.StringVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _swig_decoders.StringVector___setitem__(self, *args)

    def pop(self):
        return _swig_decoders.StringVector_pop(self)

    def append(self, x):
        return _swig_decoders.StringVector_append(self, x)

    def empty(self):
        return _swig_decoders.StringVector_empty(self)

    def size(self):
        return _swig_decoders.StringVector_size(self)

    def swap(self, v):
        return _swig_decoders.StringVector_swap(self, v)

    def begin(self):
        return _swig_decoders.StringVector_begin(self)

    def end(self):
        return _swig_decoders.StringVector_end(self)

    def rbegin(self):
        return _swig_decoders.StringVector_rbegin(self)

    def rend(self):
        return _swig_decoders.StringVector_rend(self)

    def clear(self):
        return _swig_decoders.StringVector_clear(self)

    def get_allocator(self):
        return _swig_decoders.StringVector_get_allocator(self)

    def pop_back(self):
        return _swig_decoders.StringVector_pop_back(self)

    def erase(self, *args):
        return _swig_decoders.StringVector_erase(self, *args)

    def __init__(self, *args):
        this = _swig_decoders.new_StringVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _swig_decoders.StringVector_push_back(self, x)

    def front(self):
        return _swig_decoders.StringVector_front(self)

    def back(self):
        return _swig_decoders.StringVector_back(self)

    def assign(self, n, x):
        return _swig_decoders.StringVector_assign(self, n, x)

    def resize(self, *args):
        return _swig_decoders.StringVector_resize(self, *args)

    def insert(self, *args):
        return _swig_decoders.StringVector_insert(self, *args)

    def reserve(self, n):
        return _swig_decoders.StringVector_reserve(self, n)

    def capacity(self):
        return _swig_decoders.StringVector_capacity(self)
    __swig_destroy__ = _swig_decoders.delete_StringVector
    __del__ = lambda self: None
StringVector_swigregister = _swig_decoders.StringVector_swigregister
StringVector_swigregister(StringVector)

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

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

    def __nonzero__(self):
        return _swig_decoders.VectorOfStructVectorDouble___nonzero__(self)

    def __bool__(self):
        return _swig_decoders.VectorOfStructVectorDouble___bool__(self)

    def __len__(self):
        return _swig_decoders.VectorOfStructVectorDouble___len__(self)

    def __getslice__(self, i, j):
        return _swig_decoders.VectorOfStructVectorDouble___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _swig_decoders.VectorOfStructVectorDouble___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _swig_decoders.VectorOfStructVectorDouble___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _swig_decoders.VectorOfStructVectorDouble___delitem__(self, *args)

    def __getitem__(self, *args):
        return _swig_decoders.VectorOfStructVectorDouble___getitem__(self, *args)

    def __setitem__(self, *args):
        return _swig_decoders.VectorOfStructVectorDouble___setitem__(self, *args)

    def pop(self):
        return _swig_decoders.VectorOfStructVectorDouble_pop(self)

    def append(self, x):
        return _swig_decoders.VectorOfStructVectorDouble_append(self, x)

    def empty(self):
        return _swig_decoders.VectorOfStructVectorDouble_empty(self)

    def size(self):
        return _swig_decoders.VectorOfStructVectorDouble_size(self)

    def swap(self, v):
        return _swig_decoders.VectorOfStructVectorDouble_swap(self, v)

    def begin(self):
        return _swig_decoders.VectorOfStructVectorDouble_begin(self)

    def end(self):
        return _swig_decoders.VectorOfStructVectorDouble_end(self)

    def rbegin(self):
        return _swig_decoders.VectorOfStructVectorDouble_rbegin(self)

    def rend(self):
        return _swig_decoders.VectorOfStructVectorDouble_rend(self)

    def clear(self):
        return _swig_decoders.VectorOfStructVectorDouble_clear(self)

    def get_allocator(self):
        return _swig_decoders.VectorOfStructVectorDouble_get_allocator(self)

    def pop_back(self):
        return _swig_decoders.VectorOfStructVectorDouble_pop_back(self)

    def erase(self, *args):
        return _swig_decoders.VectorOfStructVectorDouble_erase(self, *args)

    def __init__(self, *args):
        this = _swig_decoders.new_VectorOfStructVectorDouble(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _swig_decoders.VectorOfStructVectorDouble_push_back(self, x)

    def front(self):
        return _swig_decoders.VectorOfStructVectorDouble_front(self)

    def back(self):
        return _swig_decoders.VectorOfStructVectorDouble_back(self)

    def assign(self, n, x):
        return _swig_decoders.VectorOfStructVectorDouble_assign(self, n, x)

    def resize(self, *args):
        return _swig_decoders.VectorOfStructVectorDouble_resize(self, *args)

    def insert(self, *args):
        return _swig_decoders.VectorOfStructVectorDouble_insert(self, *args)

    def reserve(self, n):
        return _swig_decoders.VectorOfStructVectorDouble_reserve(self, n)

    def capacity(self):
        return _swig_decoders.VectorOfStructVectorDouble_capacity(self)
    __swig_destroy__ = _swig_decoders.delete_VectorOfStructVectorDouble
    __del__ = lambda self: None
VectorOfStructVectorDouble_swigregister = _swig_decoders.VectorOfStructVectorDouble_swigregister
VectorOfStructVectorDouble_swigregister(VectorOfStructVectorDouble)

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

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

    def __nonzero__(self):
        return _swig_decoders.VectorOfStructVectorInt___nonzero__(self)

    def __bool__(self):
        return _swig_decoders.VectorOfStructVectorInt___bool__(self)

    def __len__(self):
        return _swig_decoders.VectorOfStructVectorInt___len__(self)

    def __getslice__(self, i, j):
        return _swig_decoders.VectorOfStructVectorInt___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _swig_decoders.VectorOfStructVectorInt___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _swig_decoders.VectorOfStructVectorInt___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _swig_decoders.VectorOfStructVectorInt___delitem__(self, *args)

    def __getitem__(self, *args):
        return _swig_decoders.VectorOfStructVectorInt___getitem__(self, *args)

    def __setitem__(self, *args):
        return _swig_decoders.VectorOfStructVectorInt___setitem__(self, *args)

    def pop(self):
        return _swig_decoders.VectorOfStructVectorInt_pop(self)

    def append(self, x):
        return _swig_decoders.VectorOfStructVectorInt_append(self, x)

    def empty(self):
        return _swig_decoders.VectorOfStructVectorInt_empty(self)

    def size(self):
        return _swig_decoders.VectorOfStructVectorInt_size(self)

    def swap(self, v):
        return _swig_decoders.VectorOfStructVectorInt_swap(self, v)

    def begin(self):
        return _swig_decoders.VectorOfStructVectorInt_begin(self)

    def end(self):
        return _swig_decoders.VectorOfStructVectorInt_end(self)

    def rbegin(self):
        return _swig_decoders.VectorOfStructVectorInt_rbegin(self)

    def rend(self):
        return _swig_decoders.VectorOfStructVectorInt_rend(self)

    def clear(self):
        return _swig_decoders.VectorOfStructVectorInt_clear(self)

    def get_allocator(self):
        return _swig_decoders.VectorOfStructVectorInt_get_allocator(self)

    def pop_back(self):
        return _swig_decoders.VectorOfStructVectorInt_pop_back(self)

    def erase(self, *args):
        return _swig_decoders.VectorOfStructVectorInt_erase(self, *args)

    def __init__(self, *args):
        this = _swig_decoders.new_VectorOfStructVectorInt(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _swig_decoders.VectorOfStructVectorInt_push_back(self, x)

    def front(self):
        return _swig_decoders.VectorOfStructVectorInt_front(self)

    def back(self):
        return _swig_decoders.VectorOfStructVectorInt_back(self)

    def assign(self, n, x):
        return _swig_decoders.VectorOfStructVectorInt_assign(self, n, x)

    def resize(self, *args):
        return _swig_decoders.VectorOfStructVectorInt_resize(self, *args)

    def insert(self, *args):
        return _swig_decoders.VectorOfStructVectorInt_insert(self, *args)

    def reserve(self, n):
        return _swig_decoders.VectorOfStructVectorInt_reserve(self, n)

    def capacity(self):
        return _swig_decoders.VectorOfStructVectorInt_capacity(self)
    __swig_destroy__ = _swig_decoders.delete_VectorOfStructVectorInt
    __del__ = lambda self: None
VectorOfStructVectorInt_swigregister = _swig_decoders.VectorOfStructVectorInt_swigregister
VectorOfStructVectorInt_swigregister(VectorOfStructVectorInt)

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

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

    def __nonzero__(self):
        return _swig_decoders.FloatVector___nonzero__(self)

    def __bool__(self):
        return _swig_decoders.FloatVector___bool__(self)

    def __len__(self):
        return _swig_decoders.FloatVector___len__(self)

    def __getslice__(self, i, j):
        return _swig_decoders.FloatVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _swig_decoders.FloatVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _swig_decoders.FloatVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _swig_decoders.FloatVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _swig_decoders.FloatVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _swig_decoders.FloatVector___setitem__(self, *args)

    def pop(self):
        return _swig_decoders.FloatVector_pop(self)

    def append(self, x):
        return _swig_decoders.FloatVector_append(self, x)

    def empty(self):
        return _swig_decoders.FloatVector_empty(self)

    def size(self):
        return _swig_decoders.FloatVector_size(self)

    def swap(self, v):
        return _swig_decoders.FloatVector_swap(self, v)

    def begin(self):
        return _swig_decoders.FloatVector_begin(self)

    def end(self):
        return _swig_decoders.FloatVector_end(self)

    def rbegin(self):
        return _swig_decoders.FloatVector_rbegin(self)

    def rend(self):
        return _swig_decoders.FloatVector_rend(self)

    def clear(self):
        return _swig_decoders.FloatVector_clear(self)

    def get_allocator(self):
        return _swig_decoders.FloatVector_get_allocator(self)

    def pop_back(self):
        return _swig_decoders.FloatVector_pop_back(self)

    def erase(self, *args):
        return _swig_decoders.FloatVector_erase(self, *args)

    def __init__(self, *args):
        this = _swig_decoders.new_FloatVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _swig_decoders.FloatVector_push_back(self, x)

    def front(self):
        return _swig_decoders.FloatVector_front(self)

    def back(self):
        return _swig_decoders.FloatVector_back(self)

    def assign(self, n, x):
        return _swig_decoders.FloatVector_assign(self, n, x)

    def resize(self, *args):
        return _swig_decoders.FloatVector_resize(self, *args)

    def insert(self, *args):
        return _swig_decoders.FloatVector_insert(self, *args)

    def reserve(self, n):
        return _swig_decoders.FloatVector_reserve(self, n)

    def capacity(self):
        return _swig_decoders.FloatVector_capacity(self)
    __swig_destroy__ = _swig_decoders.delete_FloatVector
    __del__ = lambda self: None
FloatVector_swigregister = _swig_decoders.FloatVector_swigregister
FloatVector_swigregister(FloatVector)

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

    def __init__(self, *args):
        this = _swig_decoders.new_Pair(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_setmethods__["first"] = _swig_decoders.Pair_first_set
    __swig_getmethods__["first"] = _swig_decoders.Pair_first_get
    if _newclass:
        first = _swig_property(_swig_decoders.Pair_first_get, _swig_decoders.Pair_first_set)
    __swig_setmethods__["second"] = _swig_decoders.Pair_second_set
    __swig_getmethods__["second"] = _swig_decoders.Pair_second_get
    if _newclass:
        second = _swig_property(_swig_decoders.Pair_second_get, _swig_decoders.Pair_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _swig_decoders.delete_Pair
    __del__ = lambda self: None
Pair_swigregister = _swig_decoders.Pair_swigregister
Pair_swigregister(Pair)

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

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

    def __nonzero__(self):
        return _swig_decoders.PairFloatVectorVector___nonzero__(self)

    def __bool__(self):
        return _swig_decoders.PairFloatVectorVector___bool__(self)

    def __len__(self):
        return _swig_decoders.PairFloatVectorVector___len__(self)

    def __getslice__(self, i, j):
        return _swig_decoders.PairFloatVectorVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _swig_decoders.PairFloatVectorVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _swig_decoders.PairFloatVectorVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _swig_decoders.PairFloatVectorVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _swig_decoders.PairFloatVectorVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _swig_decoders.PairFloatVectorVector___setitem__(self, *args)

    def pop(self):
        return _swig_decoders.PairFloatVectorVector_pop(self)

    def append(self, x):
        return _swig_decoders.PairFloatVectorVector_append(self, x)

    def empty(self):
        return _swig_decoders.PairFloatVectorVector_empty(self)

    def size(self):
        return _swig_decoders.PairFloatVectorVector_size(self)

    def swap(self, v):
        return _swig_decoders.PairFloatVectorVector_swap(self, v)

    def begin(self):
        return _swig_decoders.PairFloatVectorVector_begin(self)

    def end(self):
        return _swig_decoders.PairFloatVectorVector_end(self)

    def rbegin(self):
        return _swig_decoders.PairFloatVectorVector_rbegin(self)

    def rend(self):
        return _swig_decoders.PairFloatVectorVector_rend(self)

    def clear(self):
        return _swig_decoders.PairFloatVectorVector_clear(self)

    def get_allocator(self):
        return _swig_decoders.PairFloatVectorVector_get_allocator(self)

    def pop_back(self):
        return _swig_decoders.PairFloatVectorVector_pop_back(self)

    def erase(self, *args):
        return _swig_decoders.PairFloatVectorVector_erase(self, *args)

    def __init__(self, *args):
        this = _swig_decoders.new_PairFloatVectorVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _swig_decoders.PairFloatVectorVector_push_back(self, x)

    def front(self):
        return _swig_decoders.PairFloatVectorVector_front(self)

    def back(self):
        return _swig_decoders.PairFloatVectorVector_back(self)

    def assign(self, n, x):
        return _swig_decoders.PairFloatVectorVector_assign(self, n, x)

    def resize(self, *args):
        return _swig_decoders.PairFloatVectorVector_resize(self, *args)

    def insert(self, *args):
        return _swig_decoders.PairFloatVectorVector_insert(self, *args)

    def reserve(self, n):
        return _swig_decoders.PairFloatVectorVector_reserve(self, n)

    def capacity(self):
        return _swig_decoders.PairFloatVectorVector_capacity(self)
    __swig_destroy__ = _swig_decoders.delete_PairFloatVectorVector
    __del__ = lambda self: None
PairFloatVectorVector_swigregister = _swig_decoders.PairFloatVectorVector_swigregister
PairFloatVectorVector_swigregister(PairFloatVectorVector)

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

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

    def __nonzero__(self):
        return _swig_decoders.PairDoubleVectorVector___nonzero__(self)

    def __bool__(self):
        return _swig_decoders.PairDoubleVectorVector___bool__(self)

    def __len__(self):
        return _swig_decoders.PairDoubleVectorVector___len__(self)

    def __getslice__(self, i, j):
        return _swig_decoders.PairDoubleVectorVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _swig_decoders.PairDoubleVectorVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _swig_decoders.PairDoubleVectorVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _swig_decoders.PairDoubleVectorVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _swig_decoders.PairDoubleVectorVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _swig_decoders.PairDoubleVectorVector___setitem__(self, *args)

    def pop(self):
        return _swig_decoders.PairDoubleVectorVector_pop(self)

    def append(self, x):
        return _swig_decoders.PairDoubleVectorVector_append(self, x)

    def empty(self):
        return _swig_decoders.PairDoubleVectorVector_empty(self)

    def size(self):
        return _swig_decoders.PairDoubleVectorVector_size(self)

    def swap(self, v):
        return _swig_decoders.PairDoubleVectorVector_swap(self, v)

    def begin(self):
        return _swig_decoders.PairDoubleVectorVector_begin(self)

    def end(self):
        return _swig_decoders.PairDoubleVectorVector_end(self)

    def rbegin(self):
        return _swig_decoders.PairDoubleVectorVector_rbegin(self)

    def rend(self):
        return _swig_decoders.PairDoubleVectorVector_rend(self)

    def clear(self):
        return _swig_decoders.PairDoubleVectorVector_clear(self)

    def get_allocator(self):
        return _swig_decoders.PairDoubleVectorVector_get_allocator(self)

    def pop_back(self):
        return _swig_decoders.PairDoubleVectorVector_pop_back(self)

    def erase(self, *args):
        return _swig_decoders.PairDoubleVectorVector_erase(self, *args)

    def __init__(self, *args):
        this = _swig_decoders.new_PairDoubleVectorVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _swig_decoders.PairDoubleVectorVector_push_back(self, x)

    def front(self):
        return _swig_decoders.PairDoubleVectorVector_front(self)

    def back(self):
        return _swig_decoders.PairDoubleVectorVector_back(self)

    def assign(self, n, x):
        return _swig_decoders.PairDoubleVectorVector_assign(self, n, x)

    def resize(self, *args):
        return _swig_decoders.PairDoubleVectorVector_resize(self, *args)

    def insert(self, *args):
        return _swig_decoders.PairDoubleVectorVector_insert(self, *args)

    def reserve(self, n):
        return _swig_decoders.PairDoubleVectorVector_reserve(self, n)

    def capacity(self):
        return _swig_decoders.PairDoubleVectorVector_capacity(self)
    __swig_destroy__ = _swig_decoders.delete_PairDoubleVectorVector
    __del__ = lambda self: None
PairDoubleVectorVector_swigregister = _swig_decoders.PairDoubleVectorVector_swigregister
PairDoubleVectorVector_swigregister(PairDoubleVectorVector)

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

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

    def __nonzero__(self):
        return _swig_decoders.PairDoubleVectorVector2___nonzero__(self)

    def __bool__(self):
        return _swig_decoders.PairDoubleVectorVector2___bool__(self)

    def __len__(self):
        return _swig_decoders.PairDoubleVectorVector2___len__(self)

    def __getslice__(self, i, j):
        return _swig_decoders.PairDoubleVectorVector2___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _swig_decoders.PairDoubleVectorVector2___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _swig_decoders.PairDoubleVectorVector2___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _swig_decoders.PairDoubleVectorVector2___delitem__(self, *args)

    def __getitem__(self, *args):
        return _swig_decoders.PairDoubleVectorVector2___getitem__(self, *args)

    def __setitem__(self, *args):
        return _swig_decoders.PairDoubleVectorVector2___setitem__(self, *args)

    def pop(self):
        return _swig_decoders.PairDoubleVectorVector2_pop(self)

    def append(self, x):
        return _swig_decoders.PairDoubleVectorVector2_append(self, x)

    def empty(self):
        return _swig_decoders.PairDoubleVectorVector2_empty(self)

    def size(self):
        return _swig_decoders.PairDoubleVectorVector2_size(self)

    def swap(self, v):
        return _swig_decoders.PairDoubleVectorVector2_swap(self, v)

    def begin(self):
        return _swig_decoders.PairDoubleVectorVector2_begin(self)

    def end(self):
        return _swig_decoders.PairDoubleVectorVector2_end(self)

    def rbegin(self):
        return _swig_decoders.PairDoubleVectorVector2_rbegin(self)

    def rend(self):
        return _swig_decoders.PairDoubleVectorVector2_rend(self)

    def clear(self):
        return _swig_decoders.PairDoubleVectorVector2_clear(self)

    def get_allocator(self):
        return _swig_decoders.PairDoubleVectorVector2_get_allocator(self)

    def pop_back(self):
        return _swig_decoders.PairDoubleVectorVector2_pop_back(self)

    def erase(self, *args):
        return _swig_decoders.PairDoubleVectorVector2_erase(self, *args)

    def __init__(self, *args):
        this = _swig_decoders.new_PairDoubleVectorVector2(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _swig_decoders.PairDoubleVectorVector2_push_back(self, x)

    def front(self):
        return _swig_decoders.PairDoubleVectorVector2_front(self)

    def back(self):
        return _swig_decoders.PairDoubleVectorVector2_back(self)

    def assign(self, n, x):
        return _swig_decoders.PairDoubleVectorVector2_assign(self, n, x)

    def resize(self, *args):
        return _swig_decoders.PairDoubleVectorVector2_resize(self, *args)

    def insert(self, *args):
        return _swig_decoders.PairDoubleVectorVector2_insert(self, *args)

    def reserve(self, n):
        return _swig_decoders.PairDoubleVectorVector2_reserve(self, n)

    def capacity(self):
        return _swig_decoders.PairDoubleVectorVector2_capacity(self)
    __swig_destroy__ = _swig_decoders.delete_PairDoubleVectorVector2
    __del__ = lambda self: None
PairDoubleVectorVector2_swigregister = _swig_decoders.PairDoubleVectorVector2_swigregister
PairDoubleVectorVector2_swigregister(PairDoubleVectorVector2)

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

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

    def __nonzero__(self):
        return _swig_decoders.DoubleVector3___nonzero__(self)

    def __bool__(self):
        return _swig_decoders.DoubleVector3___bool__(self)

    def __len__(self):
        return _swig_decoders.DoubleVector3___len__(self)

    def __getslice__(self, i, j):
        return _swig_decoders.DoubleVector3___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _swig_decoders.DoubleVector3___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _swig_decoders.DoubleVector3___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _swig_decoders.DoubleVector3___delitem__(self, *args)

    def __getitem__(self, *args):
        return _swig_decoders.DoubleVector3___getitem__(self, *args)

    def __setitem__(self, *args):
        return _swig_decoders.DoubleVector3___setitem__(self, *args)

    def pop(self):
        return _swig_decoders.DoubleVector3_pop(self)

    def append(self, x):
        return _swig_decoders.DoubleVector3_append(self, x)

    def empty(self):
        return _swig_decoders.DoubleVector3_empty(self)

    def size(self):
        return _swig_decoders.DoubleVector3_size(self)

    def swap(self, v):
        return _swig_decoders.DoubleVector3_swap(self, v)

    def begin(self):
        return _swig_decoders.DoubleVector3_begin(self)

    def end(self):
        return _swig_decoders.DoubleVector3_end(self)

    def rbegin(self):
        return _swig_decoders.DoubleVector3_rbegin(self)

    def rend(self):
        return _swig_decoders.DoubleVector3_rend(self)

    def clear(self):
        return _swig_decoders.DoubleVector3_clear(self)

    def get_allocator(self):
        return _swig_decoders.DoubleVector3_get_allocator(self)

    def pop_back(self):
        return _swig_decoders.DoubleVector3_pop_back(self)

    def erase(self, *args):
        return _swig_decoders.DoubleVector3_erase(self, *args)

    def __init__(self, *args):
        this = _swig_decoders.new_DoubleVector3(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _swig_decoders.DoubleVector3_push_back(self, x)

    def front(self):
        return _swig_decoders.DoubleVector3_front(self)

    def back(self):
        return _swig_decoders.DoubleVector3_back(self)

    def assign(self, n, x):
        return _swig_decoders.DoubleVector3_assign(self, n, x)

    def resize(self, *args):
        return _swig_decoders.DoubleVector3_resize(self, *args)

    def insert(self, *args):
        return _swig_decoders.DoubleVector3_insert(self, *args)

    def reserve(self, n):
        return _swig_decoders.DoubleVector3_reserve(self, n)

    def capacity(self):
        return _swig_decoders.DoubleVector3_capacity(self)
    __swig_destroy__ = _swig_decoders.delete_DoubleVector3
    __del__ = lambda self: None
DoubleVector3_swigregister = _swig_decoders.DoubleVector3_swigregister
DoubleVector3_swigregister(DoubleVector3)

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

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

    def __nonzero__(self):
        return _swig_decoders.IntVector3___nonzero__(self)

    def __bool__(self):
        return _swig_decoders.IntVector3___bool__(self)

    def __len__(self):
        return _swig_decoders.IntVector3___len__(self)

    def __getslice__(self, i, j):
        return _swig_decoders.IntVector3___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _swig_decoders.IntVector3___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _swig_decoders.IntVector3___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _swig_decoders.IntVector3___delitem__(self, *args)

    def __getitem__(self, *args):
        return _swig_decoders.IntVector3___getitem__(self, *args)

    def __setitem__(self, *args):
        return _swig_decoders.IntVector3___setitem__(self, *args)

    def pop(self):
        return _swig_decoders.IntVector3_pop(self)

    def append(self, x):
        return _swig_decoders.IntVector3_append(self, x)

    def empty(self):
        return _swig_decoders.IntVector3_empty(self)

    def size(self):
        return _swig_decoders.IntVector3_size(self)

    def swap(self, v):
        return _swig_decoders.IntVector3_swap(self, v)

    def begin(self):
        return _swig_decoders.IntVector3_begin(self)

    def end(self):
        return _swig_decoders.IntVector3_end(self)

    def rbegin(self):
        return _swig_decoders.IntVector3_rbegin(self)

    def rend(self):
        return _swig_decoders.IntVector3_rend(self)

    def clear(self):
        return _swig_decoders.IntVector3_clear(self)

    def get_allocator(self):
        return _swig_decoders.IntVector3_get_allocator(self)

    def pop_back(self):
        return _swig_decoders.IntVector3_pop_back(self)

    def erase(self, *args):
        return _swig_decoders.IntVector3_erase(self, *args)

    def __init__(self, *args):
        this = _swig_decoders.new_IntVector3(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _swig_decoders.IntVector3_push_back(self, x)

    def front(self):
        return _swig_decoders.IntVector3_front(self)

    def back(self):
        return _swig_decoders.IntVector3_back(self)

    def assign(self, n, x):
        return _swig_decoders.IntVector3_assign(self, n, x)

    def resize(self, *args):
        return _swig_decoders.IntVector3_resize(self, *args)

    def insert(self, *args):
        return _swig_decoders.IntVector3_insert(self, *args)

    def reserve(self, n):
        return _swig_decoders.IntVector3_reserve(self, n)

    def capacity(self):
        return _swig_decoders.IntVector3_capacity(self)
    __swig_destroy__ = _swig_decoders.delete_IntVector3
    __del__ = lambda self: None
IntVector3_swigregister = _swig_decoders.IntVector3_swigregister
IntVector3_swigregister(IntVector3)

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

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

    def __nonzero__(self):
        return _swig_decoders.TrieVector___nonzero__(self)

    def __bool__(self):
        return _swig_decoders.TrieVector___bool__(self)

    def __len__(self):
        return _swig_decoders.TrieVector___len__(self)

    def __getslice__(self, i, j):
        return _swig_decoders.TrieVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _swig_decoders.TrieVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _swig_decoders.TrieVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _swig_decoders.TrieVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _swig_decoders.TrieVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _swig_decoders.TrieVector___setitem__(self, *args)

    def pop(self):
        return _swig_decoders.TrieVector_pop(self)

    def append(self, x):
        return _swig_decoders.TrieVector_append(self, x)

    def empty(self):
        return _swig_decoders.TrieVector_empty(self)

    def size(self):
        return _swig_decoders.TrieVector_size(self)

    def swap(self, v):
        return _swig_decoders.TrieVector_swap(self, v)

    def begin(self):
        return _swig_decoders.TrieVector_begin(self)

    def end(self):
        return _swig_decoders.TrieVector_end(self)

    def rbegin(self):
        return _swig_decoders.TrieVector_rbegin(self)

    def rend(self):
        return _swig_decoders.TrieVector_rend(self)

    def clear(self):
        return _swig_decoders.TrieVector_clear(self)

    def get_allocator(self):
        return _swig_decoders.TrieVector_get_allocator(self)

    def pop_back(self):
        return _swig_decoders.TrieVector_pop_back(self)

    def erase(self, *args):
        return _swig_decoders.TrieVector_erase(self, *args)

    def __init__(self, *args):
        this = _swig_decoders.new_TrieVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _swig_decoders.TrieVector_push_back(self, x)

    def front(self):
        return _swig_decoders.TrieVector_front(self)

    def back(self):
        return _swig_decoders.TrieVector_back(self)

    def assign(self, n, x):
        return _swig_decoders.TrieVector_assign(self, n, x)

    def resize(self, *args):
        return _swig_decoders.TrieVector_resize(self, *args)

    def insert(self, *args):
        return _swig_decoders.TrieVector_insert(self, *args)

    def reserve(self, n):
        return _swig_decoders.TrieVector_reserve(self, n)

    def capacity(self):
        return _swig_decoders.TrieVector_capacity(self)
    __swig_destroy__ = _swig_decoders.delete_TrieVector
    __del__ = lambda self: None
TrieVector_swigregister = _swig_decoders.TrieVector_swigregister
TrieVector_swigregister(TrieVector)

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

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

    def __nonzero__(self):
        return _swig_decoders.BoolVector___nonzero__(self)

    def __bool__(self):
        return _swig_decoders.BoolVector___bool__(self)

    def __len__(self):
        return _swig_decoders.BoolVector___len__(self)

    def __getslice__(self, i, j):
        return _swig_decoders.BoolVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _swig_decoders.BoolVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _swig_decoders.BoolVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _swig_decoders.BoolVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _swig_decoders.BoolVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _swig_decoders.BoolVector___setitem__(self, *args)

    def pop(self):
        return _swig_decoders.BoolVector_pop(self)

    def append(self, x):
        return _swig_decoders.BoolVector_append(self, x)

    def empty(self):
        return _swig_decoders.BoolVector_empty(self)

    def size(self):
        return _swig_decoders.BoolVector_size(self)

    def swap(self, v):
        return _swig_decoders.BoolVector_swap(self, v)

    def begin(self):
        return _swig_decoders.BoolVector_begin(self)

    def end(self):
        return _swig_decoders.BoolVector_end(self)

    def rbegin(self):
        return _swig_decoders.BoolVector_rbegin(self)

    def rend(self):
        return _swig_decoders.BoolVector_rend(self)

    def clear(self):
        return _swig_decoders.BoolVector_clear(self)

    def get_allocator(self):
        return _swig_decoders.BoolVector_get_allocator(self)

    def pop_back(self):
        return _swig_decoders.BoolVector_pop_back(self)

    def erase(self, *args):
        return _swig_decoders.BoolVector_erase(self, *args)

    def __init__(self, *args):
        this = _swig_decoders.new_BoolVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _swig_decoders.BoolVector_push_back(self, x)

    def front(self):
        return _swig_decoders.BoolVector_front(self)

    def back(self):
        return _swig_decoders.BoolVector_back(self)

    def assign(self, n, x):
        return _swig_decoders.BoolVector_assign(self, n, x)

    def resize(self, *args):
        return _swig_decoders.BoolVector_resize(self, *args)

    def insert(self, *args):
        return _swig_decoders.BoolVector_insert(self, *args)

    def reserve(self, n):
        return _swig_decoders.BoolVector_reserve(self, n)

    def capacity(self):
        return _swig_decoders.BoolVector_capacity(self)
    __swig_destroy__ = _swig_decoders.delete_BoolVector
    __del__ = lambda self: None
BoolVector_swigregister = _swig_decoders.BoolVector_swigregister
BoolVector_swigregister(BoolVector)


def IntDoublePairCompSecondRev(a, b):
    return _swig_decoders.IntDoublePairCompSecondRev(a, b)
IntDoublePairCompSecondRev = _swig_decoders.IntDoublePairCompSecondRev

def StringDoublePairCompSecondRev(a, b):
    return _swig_decoders.StringDoublePairCompSecondRev(a, b)
StringDoublePairCompSecondRev = _swig_decoders.StringDoublePairCompSecondRev

def DoubleStringPairCompFirstRev(a, b):
    return _swig_decoders.DoubleStringPairCompFirstRev(a, b)
DoubleStringPairCompFirstRev = _swig_decoders.DoubleStringPairCompFirstRev
class RetriveStrEnumerateVocab(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RetriveStrEnumerateVocab, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RetriveStrEnumerateVocab, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _swig_decoders.new_RetriveStrEnumerateVocab()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def Add(self, index, str):
        return _swig_decoders.RetriveStrEnumerateVocab_Add(self, index, str)
    __swig_setmethods__["vocabulary"] = _swig_decoders.RetriveStrEnumerateVocab_vocabulary_set
    __swig_getmethods__["vocabulary"] = _swig_decoders.RetriveStrEnumerateVocab_vocabulary_get
    if _newclass:
        vocabulary = _swig_property(_swig_decoders.RetriveStrEnumerateVocab_vocabulary_get, _swig_decoders.RetriveStrEnumerateVocab_vocabulary_set)
    __swig_destroy__ = _swig_decoders.delete_RetriveStrEnumerateVocab
    __del__ = lambda self: None
RetriveStrEnumerateVocab_swigregister = _swig_decoders.RetriveStrEnumerateVocab_swigregister
RetriveStrEnumerateVocab_swigregister(RetriveStrEnumerateVocab)
cvar = _swig_decoders.cvar
OOV_SCORE = cvar.OOV_SCORE
START_TOKEN = cvar.START_TOKEN
UNK_TOKEN = cvar.UNK_TOKEN
END_TOKEN = cvar.END_TOKEN

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

    def __init__(self, alpha, beta, lm_path, vocabulary):
        this = _swig_decoders.new_Scorer(alpha, beta, lm_path, vocabulary)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _swig_decoders.delete_Scorer
    __del__ = lambda self: None

    def get_log_cond_prob(self, words):
        return _swig_decoders.Scorer_get_log_cond_prob(self, words)

    def get_sent_log_prob(self, words):
        return _swig_decoders.Scorer_get_sent_log_prob(self, words)

    def get_max_order(self):
        return _swig_decoders.Scorer_get_max_order(self)

    def get_dict_size(self):
        return _swig_decoders.Scorer_get_dict_size(self)

    def is_character_based(self):
        return _swig_decoders.Scorer_is_character_based(self)

    def reset_params(self, alpha, beta):
        return _swig_decoders.Scorer_reset_params(self, alpha, beta)

    def make_ngram(self, prefix):
        return _swig_decoders.Scorer_make_ngram(self, prefix)

    def split_labels(self, labels):
        return _swig_decoders.Scorer_split_labels(self, labels)
    __swig_setmethods__["alpha"] = _swig_decoders.Scorer_alpha_set
    __swig_getmethods__["alpha"] = _swig_decoders.Scorer_alpha_get
    if _newclass:
        alpha = _swig_property(_swig_decoders.Scorer_alpha_get, _swig_decoders.Scorer_alpha_set)
    __swig_setmethods__["beta"] = _swig_decoders.Scorer_beta_set
    __swig_getmethods__["beta"] = _swig_decoders.Scorer_beta_get
    if _newclass:
        beta = _swig_property(_swig_decoders.Scorer_beta_get, _swig_decoders.Scorer_beta_set)
    __swig_setmethods__["dictionary"] = _swig_decoders.Scorer_dictionary_set
    __swig_getmethods__["dictionary"] = _swig_decoders.Scorer_dictionary_get
    if _newclass:
        dictionary = _swig_property(_swig_decoders.Scorer_dictionary_get, _swig_decoders.Scorer_dictionary_set)
Scorer_swigregister = _swig_decoders.Scorer_swigregister
Scorer_swigregister(Scorer)


def ctc_beam_search_decoder(log_probs_seq, log_probs_idx, root, start, beam_size, blank_id=0, space_id=-1, cutoff_prob=0.999, ext_scorer=None):
    return _swig_decoders.ctc_beam_search_decoder(log_probs_seq, log_probs_idx, root, start, beam_size, blank_id, space_id, cutoff_prob, ext_scorer)
ctc_beam_search_decoder = _swig_decoders.ctc_beam_search_decoder

def ctc_beam_search_decoder_batch(batch_log_probs_seq, batch_log_probs_idx, batch_root_trie, batch_start, beam_size, num_processes, blank_id=0, space_id=-1, cutoff_prob=0.999, ext_scorer=None):
    return _swig_decoders.ctc_beam_search_decoder_batch(batch_log_probs_seq, batch_log_probs_idx, batch_root_trie, batch_start, beam_size, num_processes, blank_id, space_id, cutoff_prob, ext_scorer)
ctc_beam_search_decoder_batch = _swig_decoders.ctc_beam_search_decoder_batch

def map_sent(sent, vocabulary, greedy=False, blank_id=0):
    return _swig_decoders.map_sent(sent, vocabulary, greedy, blank_id)
map_sent = _swig_decoders.map_sent

def map_batch(batch_sents, vocabulary, num_processes, greedy=False, blank_id=0):
    return _swig_decoders.map_batch(batch_sents, vocabulary, num_processes, greedy, blank_id)
map_batch = _swig_decoders.map_batch
# This file is compatible with both classic and new-style classes.


