# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.10
#
# 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, '_utils')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_utils')
    _utils = 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('_utils', [dirname(__file__)])
        except ImportError:
            import _utils
            return _utils
        if fp is not None:
            try:
                _mod = imp.load_module('_utils', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _utils = swig_import_helper()
    del swig_import_helper
else:
    import _utils
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

PRIuPTR = _utils.PRIuPTR
PRIdPTR = _utils.PRIdPTR
LLU = _utils.LLU
LLO = _utils.LLO
LLX = _utils.LLX
false = _utils.false
true = _utils.true
OUTCOME_GENERIC_ERROR = _utils.OUTCOME_GENERIC_ERROR
OUTCOME_PARSER_ERROR = _utils.OUTCOME_PARSER_ERROR
OUTCOME_SYNTAX_ERROR = _utils.OUTCOME_SYNTAX_ERROR
OUTCOME_FILE_ERROR = _utils.OUTCOME_FILE_ERROR
OUTCOME_SUCCESS_REQUIRED_HELP = _utils.OUTCOME_SUCCESS_REQUIRED_HELP
OUTCOME_SUCCESS = _utils.OUTCOME_SUCCESS

def Utils_pkg_init() -> "void":
    """Utils_pkg_init()"""
    return _utils.Utils_pkg_init()

def Utils_pkg_quit() -> "void":
    """Utils_pkg_quit()"""
    return _utils.Utils_pkg_quit()

def Utils_FreeListOfLists(list_of_lists: 'ls_dummy') -> "void":
    """Utils_FreeListOfLists(ls_dummy list_of_lists)"""
    return _utils.Utils_FreeListOfLists(list_of_lists)

def Utils_StripPath(pathfname: 'char const *') -> "char const *":
    """Utils_StripPath(char const * pathfname) -> char const *"""
    return _utils.Utils_StripPath(pathfname)

def Utils_StripPathNoExtension(fpathname: 'char const *', filename: 'char *') -> "void":
    """Utils_StripPathNoExtension(char const * fpathname, char * filename)"""
    return _utils.Utils_StripPathNoExtension(fpathname, filename)

def Utils_StripPathNoFilenameNoExtension(fpathname: 'char const *', dirname: 'char *') -> "void":
    """Utils_StripPathNoFilenameNoExtension(char const * fpathname, char * dirname)"""
    return _utils.Utils_StripPathNoFilenameNoExtension(fpathname, dirname)

def Utils_get_temp_filename_in_dir(dir: 'char const *', templ: 'char const *') -> "char *":
    """Utils_get_temp_filename_in_dir(char const * dir, char const * templ) -> char *"""
    return _utils.Utils_get_temp_filename_in_dir(dir, templ)

def Utils_file_exists_in_paths(filename: 'char const *', paths: 'char const *', delimiters: 'char const *') -> "boolean":
    """Utils_file_exists_in_paths(char const * filename, char const * paths, char const * delimiters) -> boolean"""
    return _utils.Utils_file_exists_in_paths(filename, paths, delimiters)

def Utils_file_exists_in_directory(filename: 'char const *', directory: 'char *') -> "boolean":
    """Utils_file_exists_in_directory(char const * filename, char * directory) -> boolean"""
    return _utils.Utils_file_exists_in_directory(filename, directory)

def Utils_strcasecmp(s1: 'char const *', s2: 'char const *') -> "int":
    """Utils_strcasecmp(char const * s1, char const * s2) -> int"""
    return _utils.Utils_strcasecmp(s1, s2)

def Utils_log2_round(a: 'unsigned long long') -> "int":
    """Utils_log2_round(unsigned long long a) -> int"""
    return _utils.Utils_log2_round(a)

def Utils_start_timer(name: 'char const *') -> "void":
    """Utils_start_timer(char const * name)"""
    return _utils.Utils_start_timer(name)

def Utils_stop_timer(name: 'char const *') -> "void":
    """Utils_stop_timer(char const * name)"""
    return _utils.Utils_stop_timer(name)

def Utils_reset_timer(name: 'char const *') -> "void":
    """Utils_reset_timer(char const * name)"""
    return _utils.Utils_reset_timer(name)

def Utils_print_timer(name: 'char const *', msg: 'char const *') -> "void":
    """Utils_print_timer(char const * name, char const * msg)"""
    return _utils.Utils_print_timer(name, msg)

def Utils_str_escape_xml_file(str: 'char const *', file: 'FILE *') -> "void":
    """Utils_str_escape_xml_file(char const * str, FILE * file)"""
    return _utils.Utils_str_escape_xml_file(str, file)
ARRAY_OUT_OF_MEM = _utils.ARRAY_OUT_OF_MEM
class array_t(_object):
    """Proxy of C array_t struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, array_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, array_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["space"] = _utils.array_t_space_set
    __swig_getmethods__["space"] = _utils.array_t_space_get
    if _newclass:
        space = _swig_property(_utils.array_t_space_get, _utils.array_t_space_set)
    __swig_setmethods__["num"] = _utils.array_t_num_set
    __swig_getmethods__["num"] = _utils.array_t_num_get
    if _newclass:
        num = _swig_property(_utils.array_t_num_get, _utils.array_t_num_set)
    __swig_setmethods__["n_size"] = _utils.array_t_n_size_set
    __swig_getmethods__["n_size"] = _utils.array_t_n_size_get
    if _newclass:
        n_size = _swig_property(_utils.array_t_n_size_get, _utils.array_t_n_size_set)
    __swig_setmethods__["obj_size"] = _utils.array_t_obj_size_set
    __swig_getmethods__["obj_size"] = _utils.array_t_obj_size_get
    if _newclass:
        obj_size = _swig_property(_utils.array_t_obj_size_get, _utils.array_t_obj_size_set)
    __swig_setmethods__["index"] = _utils.array_t_index_set
    __swig_getmethods__["index"] = _utils.array_t_index_get
    if _newclass:
        index = _swig_property(_utils.array_t_index_get, _utils.array_t_index_set)

    def __init__(self):
        """__init__(array_t self) -> array_t"""
        this = _utils.new_array_t()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _utils.delete_array_t
    __del__ = lambda self: None
array_t_swigregister = _utils.array_t_swigregister
array_t_swigregister(array_t)


def array_do_alloc(arg1: 'int', arg2: 'int') -> "array_t *":
    """array_do_alloc(int arg1, int arg2) -> array_t"""
    return _utils.array_do_alloc(arg1, arg2)

def array_dup(arg1: 'array_t') -> "array_t *":
    """array_dup(array_t arg1) -> array_t"""
    return _utils.array_dup(arg1)

def array_join(arg1: 'array_t', arg2: 'array_t') -> "array_t *":
    """array_join(array_t arg1, array_t arg2) -> array_t"""
    return _utils.array_join(arg1, arg2)

def array_free(arg1: 'array_t') -> "void":
    """array_free(array_t arg1)"""
    return _utils.array_free(arg1)

def array_append(arg1: 'array_t', arg2: 'array_t') -> "int":
    """array_append(array_t arg1, array_t arg2) -> int"""
    return _utils.array_append(arg1, arg2)

def array_sort(arg1: 'array_t', arg2: 'int (*)()') -> "void":
    """array_sort(array_t arg1, int (*)() arg2)"""
    return _utils.array_sort(arg1, arg2)

def array_uniq(arg1: 'array_t', arg2: 'int (*)()', arg3: 'void (*)()') -> "void":
    """array_uniq(array_t arg1, int (*)() arg2, void (*)() arg3)"""
    return _utils.array_uniq(arg1, arg2, arg3)

def array_abort(arg1: 'array_t', arg2: 'int') -> "int":
    """array_abort(array_t arg1, int arg2) -> int"""
    return _utils.array_abort(arg1, arg2)

def array_resize(arg1: 'array_t', arg2: 'int') -> "int":
    """array_resize(array_t arg1, int arg2) -> int"""
    return _utils.array_resize(arg1, arg2)

def array_do_data(arg1: 'array_t') -> "char *":
    """array_do_data(array_t arg1) -> char *"""
    return _utils.array_do_data(arg1)

def new_assoc() -> "hash_ptr":
    """new_assoc() -> hash_ptr"""
    return _utils.new_assoc()

def new_assoc_with_size(initial_size: 'int') -> "hash_ptr":
    """new_assoc_with_size(int initial_size) -> hash_ptr"""
    return _utils.new_assoc_with_size(initial_size)

def new_assoc_with_params(compare_fun: 'ST_PFICPCP', hash_fun: 'ST_PFICPI') -> "hash_ptr":
    """new_assoc_with_params(ST_PFICPCP compare_fun, ST_PFICPI hash_fun) -> hash_ptr"""
    return _utils.new_assoc_with_params(compare_fun, hash_fun)

def new_assoc_string_key() -> "hash_ptr":
    """new_assoc_string_key() -> hash_ptr"""
    return _utils.new_assoc_string_key()

def free_assoc(hash: 'hash_ptr') -> "void":
    """free_assoc(hash_ptr hash)"""
    return _utils.free_assoc(hash)

def copy_assoc(hash: 'hash_ptr') -> "hash_ptr":
    """copy_assoc(hash_ptr hash) -> hash_ptr"""
    return _utils.copy_assoc(hash)

def find_assoc(arg1: 'hash_ptr', arg2: 'node_ptr') -> "node_ptr":
    """find_assoc(hash_ptr arg1, node_ptr arg2) -> node_ptr"""
    return _utils.find_assoc(arg1, arg2)

def insert_assoc(arg1: 'hash_ptr', arg2: 'node_ptr', arg3: 'node_ptr') -> "void":
    """insert_assoc(hash_ptr arg1, node_ptr arg2, node_ptr arg3)"""
    return _utils.insert_assoc(arg1, arg2, arg3)

def remove_assoc(hash: 'hash_ptr', key: 'node_ptr') -> "node_ptr":
    """remove_assoc(hash_ptr hash, node_ptr key) -> node_ptr"""
    return _utils.remove_assoc(hash, key)

def assoc_get_keys(hash: 'hash_ptr', ignore_nils: 'boolean') -> "node_ptr":
    """assoc_get_keys(hash_ptr hash, boolean ignore_nils) -> node_ptr"""
    return _utils.assoc_get_keys(hash, ignore_nils)

def clear_assoc_and_free_entries(arg1: 'hash_ptr', arg2: 'ST_PFSR') -> "void":
    """clear_assoc_and_free_entries(hash_ptr arg1, ST_PFSR arg2)"""
    return _utils.clear_assoc_and_free_entries(arg1, arg2)

def clear_assoc_and_free_entries_arg(hash: 'hash_ptr', fn: 'ST_PFSR', arg: 'char *') -> "void":
    """clear_assoc_and_free_entries_arg(hash_ptr hash, ST_PFSR fn, char * arg)"""
    return _utils.clear_assoc_and_free_entries_arg(hash, fn, arg)

def clear_assoc(hash: 'hash_ptr') -> "void":
    """clear_assoc(hash_ptr hash)"""
    return _utils.clear_assoc(hash)

def assoc_foreach(hash: 'hash_ptr', fn: 'ST_PFSR', arg: 'char *') -> "void":
    """assoc_foreach(hash_ptr hash, ST_PFSR fn, char * arg)"""
    return _utils.assoc_foreach(hash, fn, arg)
class avl_node_struct(_object):
    """Proxy of C avl_node_struct struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, avl_node_struct, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, avl_node_struct, name)
    __repr__ = _swig_repr
    __swig_setmethods__["left"] = _utils.avl_node_struct_left_set
    __swig_getmethods__["left"] = _utils.avl_node_struct_left_get
    if _newclass:
        left = _swig_property(_utils.avl_node_struct_left_get, _utils.avl_node_struct_left_set)
    __swig_setmethods__["right"] = _utils.avl_node_struct_right_set
    __swig_getmethods__["right"] = _utils.avl_node_struct_right_get
    if _newclass:
        right = _swig_property(_utils.avl_node_struct_right_get, _utils.avl_node_struct_right_set)
    __swig_setmethods__["key"] = _utils.avl_node_struct_key_set
    __swig_getmethods__["key"] = _utils.avl_node_struct_key_get
    if _newclass:
        key = _swig_property(_utils.avl_node_struct_key_get, _utils.avl_node_struct_key_set)
    __swig_setmethods__["value"] = _utils.avl_node_struct_value_set
    __swig_getmethods__["value"] = _utils.avl_node_struct_value_get
    if _newclass:
        value = _swig_property(_utils.avl_node_struct_value_get, _utils.avl_node_struct_value_set)
    __swig_setmethods__["height"] = _utils.avl_node_struct_height_set
    __swig_getmethods__["height"] = _utils.avl_node_struct_height_get
    if _newclass:
        height = _swig_property(_utils.avl_node_struct_height_get, _utils.avl_node_struct_height_set)

    def __init__(self):
        """__init__(avl_node_struct self) -> avl_node_struct"""
        this = _utils.new_avl_node_struct()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _utils.delete_avl_node_struct
    __del__ = lambda self: None
avl_node_struct_swigregister = _utils.avl_node_struct_swigregister
avl_node_struct_swigregister(avl_node_struct)
cvar = _utils.cvar

class avl_tree_struct(_object):
    """Proxy of C avl_tree_struct struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, avl_tree_struct, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, avl_tree_struct, name)
    __repr__ = _swig_repr
    __swig_setmethods__["root"] = _utils.avl_tree_struct_root_set
    __swig_getmethods__["root"] = _utils.avl_tree_struct_root_get
    if _newclass:
        root = _swig_property(_utils.avl_tree_struct_root_get, _utils.avl_tree_struct_root_set)
    __swig_setmethods__["compar"] = _utils.avl_tree_struct_compar_set
    __swig_getmethods__["compar"] = _utils.avl_tree_struct_compar_get
    if _newclass:
        compar = _swig_property(_utils.avl_tree_struct_compar_get, _utils.avl_tree_struct_compar_set)
    __swig_setmethods__["num_entries"] = _utils.avl_tree_struct_num_entries_set
    __swig_getmethods__["num_entries"] = _utils.avl_tree_struct_num_entries_get
    if _newclass:
        num_entries = _swig_property(_utils.avl_tree_struct_num_entries_get, _utils.avl_tree_struct_num_entries_set)
    __swig_setmethods__["modified"] = _utils.avl_tree_struct_modified_set
    __swig_getmethods__["modified"] = _utils.avl_tree_struct_modified_get
    if _newclass:
        modified = _swig_property(_utils.avl_tree_struct_modified_get, _utils.avl_tree_struct_modified_set)

    def __init__(self):
        """__init__(avl_tree_struct self) -> avl_tree_struct"""
        this = _utils.new_avl_tree_struct()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _utils.delete_avl_tree_struct
    __del__ = lambda self: None
avl_tree_struct_swigregister = _utils.avl_tree_struct_swigregister
avl_tree_struct_swigregister(avl_tree_struct)

class avl_generator_struct(_object):
    """Proxy of C avl_generator_struct struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, avl_generator_struct, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, avl_generator_struct, name)
    __repr__ = _swig_repr
    __swig_setmethods__["tree"] = _utils.avl_generator_struct_tree_set
    __swig_getmethods__["tree"] = _utils.avl_generator_struct_tree_get
    if _newclass:
        tree = _swig_property(_utils.avl_generator_struct_tree_get, _utils.avl_generator_struct_tree_set)
    __swig_setmethods__["nodelist"] = _utils.avl_generator_struct_nodelist_set
    __swig_getmethods__["nodelist"] = _utils.avl_generator_struct_nodelist_get
    if _newclass:
        nodelist = _swig_property(_utils.avl_generator_struct_nodelist_get, _utils.avl_generator_struct_nodelist_set)
    __swig_setmethods__["count"] = _utils.avl_generator_struct_count_set
    __swig_getmethods__["count"] = _utils.avl_generator_struct_count_get
    if _newclass:
        count = _swig_property(_utils.avl_generator_struct_count_get, _utils.avl_generator_struct_count_set)

    def __init__(self):
        """__init__(avl_generator_struct self) -> avl_generator_struct"""
        this = _utils.new_avl_generator_struct()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _utils.delete_avl_generator_struct
    __del__ = lambda self: None
avl_generator_struct_swigregister = _utils.avl_generator_struct_swigregister
avl_generator_struct_swigregister(avl_generator_struct)

AVL_FORWARD = _utils.AVL_FORWARD
AVL_BACKWARD = _utils.AVL_BACKWARD

def avl_init_table(arg1: 'int (*)()') -> "avl_tree *":
    """avl_init_table(int (*)() arg1) -> avl_tree_struct"""
    return _utils.avl_init_table(arg1)

def avl_delete(arg1: 'avl_tree_struct', arg2: 'char **', arg3: 'char **') -> "int":
    """avl_delete(avl_tree_struct arg1, char ** arg2, char ** arg3) -> int"""
    return _utils.avl_delete(arg1, arg2, arg3)

def avl_insert(arg1: 'avl_tree_struct', arg2: 'char *', arg3: 'char *') -> "int":
    """avl_insert(avl_tree_struct arg1, char * arg2, char * arg3) -> int"""
    return _utils.avl_insert(arg1, arg2, arg3)

def avl_lookup(arg1: 'avl_tree_struct', arg2: 'char *', arg3: 'char **') -> "int":
    """avl_lookup(avl_tree_struct arg1, char * arg2, char ** arg3) -> int"""
    return _utils.avl_lookup(arg1, arg2, arg3)

def avl_first(arg1: 'avl_tree_struct', arg2: 'char **', arg3: 'char **') -> "int":
    """avl_first(avl_tree_struct arg1, char ** arg2, char ** arg3) -> int"""
    return _utils.avl_first(arg1, arg2, arg3)

def avl_last(arg1: 'avl_tree_struct', arg2: 'char **', arg3: 'char **') -> "int":
    """avl_last(avl_tree_struct arg1, char ** arg2, char ** arg3) -> int"""
    return _utils.avl_last(arg1, arg2, arg3)

def avl_find_or_add(arg1: 'avl_tree_struct', arg2: 'char *', arg3: 'char ***') -> "int":
    """avl_find_or_add(avl_tree_struct arg1, char * arg2, char *** arg3) -> int"""
    return _utils.avl_find_or_add(arg1, arg2, arg3)

def avl_count(arg1: 'avl_tree_struct') -> "int":
    """avl_count(avl_tree_struct arg1) -> int"""
    return _utils.avl_count(arg1)

def avl_numcmp(arg1: 'char *', arg2: 'char *') -> "int":
    """avl_numcmp(char * arg1, char * arg2) -> int"""
    return _utils.avl_numcmp(arg1, arg2)

def avl_gen(arg1: 'avl_generator_struct', arg2: 'char **', arg3: 'char **') -> "int":
    """avl_gen(avl_generator_struct arg1, char ** arg2, char ** arg3) -> int"""
    return _utils.avl_gen(arg1, arg2, arg3)

def avl_foreach(arg1: 'avl_tree_struct', arg2: 'void (*)()', arg3: 'int') -> "void":
    """avl_foreach(avl_tree_struct arg1, void (*)() arg2, int arg3)"""
    return _utils.avl_foreach(arg1, arg2, arg3)

def avl_free_table(arg1: 'avl_tree_struct', arg2: 'void (*)()', arg3: 'void (*)()') -> "void":
    """avl_free_table(avl_tree_struct arg1, void (*)() arg2, void (*)() arg3)"""
    return _utils.avl_free_table(arg1, arg2, arg3)

def avl_free_gen(arg1: 'avl_generator_struct') -> "void":
    """avl_free_gen(avl_generator_struct arg1)"""
    return _utils.avl_free_gen(arg1)

def avl_init_gen(arg1: 'avl_tree_struct', arg2: 'int') -> "avl_generator *":
    """avl_init_gen(avl_tree_struct arg1, int arg2) -> avl_generator_struct"""
    return _utils.avl_init_gen(arg1, arg2)
FAILURE_DIV_BY_ZERO = _utils.FAILURE_DIV_BY_ZERO
FAILURE_CASE_NOT_EXHAUSTIVE = _utils.FAILURE_CASE_NOT_EXHAUSTIVE
FAILURE_ARRAY_OUT_OF_BOUNDS = _utils.FAILURE_ARRAY_OUT_OF_BOUNDS
FAILURE_UNSPECIFIED = _utils.FAILURE_UNSPECIFIED

def init_the_node() -> "void":
    """init_the_node()"""
    return _utils.init_the_node()

def set_the_node(arg1: 'node_ptr') -> "void":
    """set_the_node(node_ptr arg1)"""
    return _utils.set_the_node(arg1)

def get_the_node() -> "node_ptr":
    """get_the_node() -> node_ptr"""
    return _utils.get_the_node()

def io_atom_isempty() -> "int":
    """io_atom_isempty() -> int"""
    return _utils.io_atom_isempty()

def io_atom_push(arg1: 'node_ptr') -> "void":
    """io_atom_push(node_ptr arg1)"""
    return _utils.io_atom_push(arg1)

def io_atom_pop() -> "void":
    """io_atom_pop()"""
    return _utils.io_atom_pop()

def io_atom_head() -> "node_ptr":
    """io_atom_head() -> node_ptr"""
    return _utils.io_atom_head()

def print_io_atom_stack(fd: 'FILE *') -> "void":
    """print_io_atom_stack(FILE * fd)"""
    return _utils.print_io_atom_stack(fd)

def start_parsing_err() -> "void":
    """start_parsing_err()"""
    return _utils.start_parsing_err()

def nusmv_exit(arg1: 'int') -> "void":
    """nusmv_exit(int arg1)"""
    return _utils.nusmv_exit(arg1)

def rpterr(arg1: 'char const *') -> "void":
    """rpterr(char const * arg1)"""
    return _utils.rpterr(arg1)

def rpterr_node(node: 'node_ptr', fmt: 'char const *') -> "void":
    """rpterr_node(node_ptr node, char const * fmt)"""
    return _utils.rpterr_node(node, fmt)

def internal_error(arg1: 'char const *') -> "void":
    """internal_error(char const * arg1)"""
    return _utils.internal_error(arg1)

def report_failure_node(arg1: 'node_ptr') -> "void":
    """report_failure_node(node_ptr arg1)"""
    return _utils.report_failure_node(arg1)

def warning_failure_node(n: 'node_ptr') -> "void":
    """warning_failure_node(node_ptr n)"""
    return _utils.warning_failure_node(n)

def warning_case_not_exhaustive(arg1: 'node_ptr') -> "void":
    """warning_case_not_exhaustive(node_ptr arg1)"""
    return _utils.warning_case_not_exhaustive(arg1)

def warning_possible_div_by_zero(failure: 'node_ptr') -> "void":
    """warning_possible_div_by_zero(node_ptr failure)"""
    return _utils.warning_possible_div_by_zero(failure)

def error_div_by_zero(expr: 'node_ptr') -> "void":
    """error_div_by_zero(node_ptr expr)"""
    return _utils.error_div_by_zero(expr)

def error_div_by_nonconst(expr: 'node_ptr') -> "void":
    """error_div_by_nonconst(node_ptr expr)"""
    return _utils.error_div_by_nonconst(expr)

def warning_possible_array_out_of_bounds(failure: 'node_ptr') -> "void":
    """warning_possible_array_out_of_bounds(node_ptr failure)"""
    return _utils.warning_possible_array_out_of_bounds(failure)

def error_array_out_of_bounds(index: 'int', low: 'int', high: 'int') -> "void":
    """error_array_out_of_bounds(int index, int low, int high)"""
    return _utils.error_array_out_of_bounds(index, low, high)

def error_lhs_of_index_is_not_array() -> "void":
    """error_lhs_of_index_is_not_array()"""
    return _utils.error_lhs_of_index_is_not_array()

def range_error(arg1: 'node_ptr', arg2: 'node_ptr') -> "void":
    """range_error(node_ptr arg1, node_ptr arg2)"""
    return _utils.range_error(arg1, arg2)

def range_warning(arg1: 'node_ptr', arg2: 'node_ptr') -> "void":
    """range_warning(node_ptr arg1, node_ptr arg2)"""
    return _utils.range_warning(arg1, arg2)

def type_error(arg1: 'node_ptr') -> "void":
    """type_error(node_ptr arg1)"""
    return _utils.type_error(arg1)

def error_shadowing(s: 'node_ptr') -> "void":
    """error_shadowing(node_ptr s)"""
    return _utils.error_shadowing(s)

def error_redefining(arg1: 'node_ptr') -> "void":
    """error_redefining(node_ptr arg1)"""
    return _utils.error_redefining(arg1)

def error_redefining_operational_symbol(arg1: 'node_ptr') -> "void":
    """error_redefining_operational_symbol(node_ptr arg1)"""
    return _utils.error_redefining_operational_symbol(arg1)

def error_redefining_input_var(s: 'node_ptr') -> "void":
    """error_redefining_input_var(node_ptr s)"""
    return _utils.error_redefining_input_var(s)

def error_reassigning(s: 'node_ptr') -> "void":
    """error_reassigning(node_ptr s)"""
    return _utils.error_reassigning(s)

def error_assign_input_var(s: 'node_ptr') -> "void":
    """error_assign_input_var(node_ptr s)"""
    return _utils.error_assign_input_var(s)

def error_assign_frozen_var(s: 'node_ptr') -> "void":
    """error_assign_frozen_var(node_ptr s)"""
    return _utils.error_assign_frozen_var(s)

def error_assign_expected_var(s: 'node_ptr') -> "void":
    """error_assign_expected_var(node_ptr s)"""
    return _utils.error_assign_expected_var(s)

def error_ambiguous(s: 'node_ptr') -> "void":
    """error_ambiguous(node_ptr s)"""
    return _utils.error_ambiguous(s)

def error_undefined(arg1: 'node_ptr') -> "void":
    """error_undefined(node_ptr arg1)"""
    return _utils.error_undefined(arg1)

def error_circular(arg1: 'node_ptr') -> "void":
    """error_circular(node_ptr arg1)"""
    return _utils.error_circular(arg1)

def error_too_many_vars() -> "void":
    """error_too_many_vars()"""
    return _utils.error_too_many_vars()

def error_not_proper_number(op: 'char const *', arg2: 'node_ptr') -> "void":
    """error_not_proper_number(char const * op, node_ptr arg2)"""
    return _utils.error_not_proper_number(op, arg2)

def error_not_proper_numbers(op: 'char const *', arg2: 'node_ptr', arg3: 'node_ptr') -> "void":
    """error_not_proper_numbers(char const * op, node_ptr arg2, node_ptr arg3)"""
    return _utils.error_not_proper_numbers(op, arg2, arg3)

def error_multiple_assignment(arg1: 'node_ptr') -> "void":
    """error_multiple_assignment(node_ptr arg1)"""
    return _utils.error_multiple_assignment(arg1)

def error_empty_range(arg1: 'node_ptr', arg2: 'int', arg3: 'int') -> "void":
    """error_empty_range(node_ptr arg1, int arg2, int arg3)"""
    return _utils.error_empty_range(arg1, arg2, arg3)

def error_not_constant_resize_width(arg1: 'node_ptr') -> "void":
    """error_not_constant_resize_width(node_ptr arg1)"""
    return _utils.error_not_constant_resize_width(arg1)

def error_not_constant_extend_width(arg1: 'node_ptr') -> "void":
    """error_not_constant_extend_width(node_ptr arg1)"""
    return _utils.error_not_constant_extend_width(arg1)

def error_not_constant_wtoint(arg1: 'node_ptr') -> "void":
    """error_not_constant_wtoint(node_ptr arg1)"""
    return _utils.error_not_constant_wtoint(arg1)

def error_not_constant_width_of_word_type(arg1: 'node_ptr') -> "void":
    """error_not_constant_width_of_word_type(node_ptr arg1)"""
    return _utils.error_not_constant_width_of_word_type(arg1)

def error_not_constant_width_of_word_array_type(arg1: 'node_ptr') -> "void":
    """error_not_constant_width_of_word_array_type(node_ptr arg1)"""
    return _utils.error_not_constant_width_of_word_array_type(arg1)

def error_not_constant_width_of_array_type(arg1: 'node_ptr') -> "void":
    """error_not_constant_width_of_array_type(node_ptr arg1)"""
    return _utils.error_not_constant_width_of_array_type(arg1)

def error_wrong_word_operand(msg: 'char const *', arg2: 'node_ptr') -> "void":
    """error_wrong_word_operand(char const * msg, node_ptr arg2)"""
    return _utils.error_wrong_word_operand(msg, arg2)

def error_assign_both(arg1: 'node_ptr', arg2: 'node_ptr', arg3: 'int', arg4: 'int') -> "void":
    """error_assign_both(node_ptr arg1, node_ptr arg2, int arg3, int arg4)"""
    return _utils.error_assign_both(arg1, arg2, arg3, arg4)

def error_unknown_var_in_order_file(arg1: 'node_ptr') -> "void":
    """error_unknown_var_in_order_file(node_ptr arg1)"""
    return _utils.error_unknown_var_in_order_file(arg1)

def error_var_appear_twice_in_order_file(arg1: 'node_ptr') -> "void":
    """error_var_appear_twice_in_order_file(node_ptr arg1)"""
    return _utils.error_var_appear_twice_in_order_file(arg1)

def warning_var_appear_twice_in_order_file(arg1: 'node_ptr') -> "void":
    """warning_var_appear_twice_in_order_file(node_ptr arg1)"""
    return _utils.warning_var_appear_twice_in_order_file(arg1)

def warning_id_appears_twice_in_idlist_file(n: 'node_ptr') -> "void":
    """warning_id_appears_twice_in_idlist_file(node_ptr n)"""
    return _utils.warning_id_appears_twice_in_idlist_file(n)

def warning_variable_not_declared(arg1: 'node_ptr') -> "void":
    """warning_variable_not_declared(node_ptr arg1)"""
    return _utils.warning_variable_not_declared(arg1)

def warning_missing_variable(arg1: 'node_ptr') -> "void":
    """warning_missing_variable(node_ptr arg1)"""
    return _utils.warning_missing_variable(arg1)

def warning_missing_variables(vars_list: 'NodeList_ptr') -> "void":
    """warning_missing_variables(NodeList_ptr vars_list)"""
    return _utils.warning_missing_variables(vars_list)

def warning_non_ag_only_spec(arg1: 'Prop_ptr') -> "void":
    """warning_non_ag_only_spec(Prop_ptr arg1)"""
    return _utils.warning_non_ag_only_spec(arg1)

def warning_ag_only_without_reachables() -> "void":
    """warning_ag_only_without_reachables()"""
    return _utils.warning_ag_only_without_reachables()

def warning_fsm_init_empty() -> "void":
    """warning_fsm_init_empty()"""
    return _utils.warning_fsm_init_empty()

def warning_fsm_fairness_empty() -> "void":
    """warning_fsm_fairness_empty()"""
    return _utils.warning_fsm_fairness_empty()

def warning_fsm_init_and_fairness_empty() -> "void":
    """warning_fsm_init_and_fairness_empty()"""
    return _utils.warning_fsm_init_and_fairness_empty()

def warning_fsm_invar_empty() -> "void":
    """warning_fsm_invar_empty()"""
    return _utils.warning_fsm_invar_empty()

def error_var_not_in_order_file(arg1: 'node_ptr') -> "void":
    """error_var_not_in_order_file(node_ptr arg1)"""
    return _utils.error_var_not_in_order_file(arg1)

def error_out_of_memory(arg1: 'size_t') -> "void":
    """error_out_of_memory(size_t arg1)"""
    return _utils.error_out_of_memory(arg1)

def error_invalid_subrange(range: 'node_ptr') -> "void":
    """error_invalid_subrange(node_ptr range)"""
    return _utils.error_invalid_subrange(range)

def error_invalid_bool_cast(expr: 'node_ptr') -> "void":
    """error_invalid_bool_cast(node_ptr expr)"""
    return _utils.error_invalid_bool_cast(expr)

def error_invalid_toint_cast(expr: 'node_ptr') -> "void":
    """error_invalid_toint_cast(node_ptr expr)"""
    return _utils.error_invalid_toint_cast(expr)

def error_out_of_bounds_word_toint_cast(expr: 'node_ptr') -> "void":
    """error_out_of_bounds_word_toint_cast(node_ptr expr)"""
    return _utils.error_out_of_bounds_word_toint_cast(expr)

def error_invalid_count_operator(expr: 'node_ptr') -> "void":
    """error_invalid_count_operator(node_ptr expr)"""
    return _utils.error_invalid_count_operator(expr)

def error_invalid_enum_value(value: 'node_ptr') -> "void":
    """error_invalid_enum_value(node_ptr value)"""
    return _utils.error_invalid_enum_value(value)

def error_game_definition_contains_input_vars(var_name: 'node_ptr') -> "void":
    """error_game_definition_contains_input_vars(node_ptr var_name)"""
    return _utils.error_game_definition_contains_input_vars(var_name)

def error_property_contains_input_vars(arg1: 'Prop_ptr') -> "void":
    """error_property_contains_input_vars(Prop_ptr arg1)"""
    return _utils.error_property_contains_input_vars(arg1)

def error_assign_exp_contains_input_vars(arg1: 'node_ptr') -> "void":
    """error_assign_exp_contains_input_vars(node_ptr arg1)"""
    return _utils.error_assign_exp_contains_input_vars(arg1)

def error_next_exp_contains_input_vars(arg1: 'node_ptr') -> "void":
    """error_next_exp_contains_input_vars(node_ptr arg1)"""
    return _utils.error_next_exp_contains_input_vars(arg1)

def error_invar_exp_contains_input_vars(arg1: 'node_ptr') -> "void":
    """error_invar_exp_contains_input_vars(node_ptr arg1)"""
    return _utils.error_invar_exp_contains_input_vars(arg1)

def error_init_exp_contains_input_vars(arg1: 'node_ptr') -> "void":
    """error_init_exp_contains_input_vars(node_ptr arg1)"""
    return _utils.error_init_exp_contains_input_vars(arg1)

def error_second_player_var(arg1: 'node_ptr') -> "void":
    """error_second_player_var(node_ptr arg1)"""
    return _utils.error_second_player_var(arg1)

def error_second_player_next_var(arg1: 'node_ptr') -> "void":
    """error_second_player_next_var(node_ptr arg1)"""
    return _utils.error_second_player_next_var(arg1)

def error_unknown_preprocessor(prep_name: 'char const *') -> "void":
    """error_unknown_preprocessor(char const * prep_name)"""
    return _utils.error_unknown_preprocessor(prep_name)

def error_type_system_violation() -> "void":
    """error_type_system_violation()"""
    return _utils.error_type_system_violation()

def error_psl_not_supported_feature() -> "void":
    """error_psl_not_supported_feature()"""
    return _utils.error_psl_not_supported_feature()

def error_psl_not_supported_feature_next_number() -> "void":
    """error_psl_not_supported_feature_next_number()"""
    return _utils.error_psl_not_supported_feature_next_number()

def error_not_supported_feature(msg: 'char const *') -> "void":
    """error_not_supported_feature(char const * msg)"""
    return _utils.error_not_supported_feature(msg)

def error_expected_number() -> "void":
    """error_expected_number()"""
    return _utils.error_expected_number()

def warning_psl_not_supported_feature(psl_spec: 'node_ptr', index: 'int') -> "void":
    """warning_psl_not_supported_feature(node_ptr psl_spec, int index)"""
    return _utils.warning_psl_not_supported_feature(psl_spec, index)

def error_psl_repeated_replicator_id() -> "void":
    """error_psl_repeated_replicator_id()"""
    return _utils.error_psl_repeated_replicator_id()

def error_invalid_number(szNumber: 'char const *') -> "void":
    """error_invalid_number(char const * szNumber)"""
    return _utils.error_invalid_number(szNumber)

def error_bmc_invalid_k_l(k: 'int const', l: 'int const') -> "void":
    """error_bmc_invalid_k_l(int const k, int const l)"""
    return _utils.error_bmc_invalid_k_l(k, l)

def error_property_already_specified() -> "void":
    """error_property_already_specified()"""
    return _utils.error_property_already_specified()

def error_invalid_numeric_value(value: 'int', reason: 'char const *') -> "void":
    """error_invalid_numeric_value(int value, char const * reason)"""
    return _utils.error_invalid_numeric_value(value, reason)

def error_file_not_found(filename: 'char const *') -> "void":
    """error_file_not_found(char const * filename)"""
    return _utils.error_file_not_found(filename)

def warning_processes_deprecated() -> "void":
    """warning_processes_deprecated()"""
    return _utils.warning_processes_deprecated()

def error_not_word_wsizeof(expr: 'node_ptr') -> "void":
    """error_not_word_wsizeof(node_ptr expr)"""
    return _utils.error_not_word_wsizeof(expr)

def finish_parsing_err() -> "void":
    """finish_parsing_err()"""
    return _utils.finish_parsing_err()

def error_reset_and_exit(val: 'int') -> "void":
    """error_reset_and_exit(int val)"""
    return _utils.error_reset_and_exit(val)

def init_memory() -> "void":
    """init_memory()"""
    return _utils.init_memory()

def failure_make(msg: 'char const *', kind: 'FailureKind', lineno: 'int') -> "node_ptr":
    """failure_make(char const * msg, FailureKind kind, int lineno) -> node_ptr"""
    return _utils.failure_make(msg, kind, lineno)

def failure_get_msg(failure: 'node_ptr') -> "char const *":
    """failure_get_msg(node_ptr failure) -> char const *"""
    return _utils.failure_get_msg(failure)

def failure_get_kind(failure: 'node_ptr') -> "FailureKind":
    """failure_get_kind(node_ptr failure) -> FailureKind"""
    return _utils.failure_get_kind(failure)

def failure_get_lineno(failure: 'node_ptr') -> "int":
    """failure_get_lineno(node_ptr failure) -> int"""
    return _utils.failure_get_lineno(failure)

def util_newlongjmp() -> "sigjmp_buf *":
    """util_newlongjmp() -> sigjmp_buf *"""
    return _utils.util_newlongjmp()

def util_longjmp() -> "void":
    """util_longjmp()"""
    return _utils.util_longjmp()

def util_cancellongjmp() -> "void":
    """util_cancellongjmp()"""
    return _utils.util_cancellongjmp()

def util_resetlongjmp() -> "void":
    """util_resetlongjmp()"""
    return _utils.util_resetlongjmp()
HEAP_MAXLENGTH_INIT = _utils.HEAP_MAXLENGTH_INIT

def heap_create() -> "heap":
    """heap_create() -> heap"""
    return _utils.heap_create()

def heap_destroy(h: 'heap') -> "void":
    """heap_destroy(heap h)"""
    return _utils.heap_destroy(h)

def heap_add(h: 'heap', val: 'float', el: 'void *') -> "void":
    """heap_add(heap h, float val, void * el)"""
    return _utils.heap_add(h, val, el)

def heap_isempty(h: 'heap') -> "int":
    """heap_isempty(heap h) -> int"""
    return _utils.heap_isempty(h)

def heap_getmax(h: 'heap') -> "void *":
    """heap_getmax(heap h) -> void *"""
    return _utils.heap_getmax(h)
class ls_dummy(_object):
    """Proxy of C ls_dummy_defn struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ls_dummy, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ls_dummy, name)
    __repr__ = _swig_repr
    __swig_setmethods__["dummy"] = _utils.ls_dummy_dummy_set
    __swig_getmethods__["dummy"] = _utils.ls_dummy_dummy_get
    if _newclass:
        dummy = _swig_property(_utils.ls_dummy_dummy_get, _utils.ls_dummy_dummy_set)

    def __init__(self):
        """__init__(ls_dummy_defn self) -> ls_dummy"""
        this = _utils.new_ls_dummy()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _utils.delete_ls_dummy
    __del__ = lambda self: None
ls_dummy_swigregister = _utils.ls_dummy_swigregister
ls_dummy_swigregister(ls_dummy)

LS_NIL = _utils.LS_NIL
LS_BADSTATE = _utils.LS_BADSTATE
LS_BADPARAM = _utils.LS_BADPARAM
LS_NOMORE = _utils.LS_NOMORE
LS_OK = _utils.LS_OK
LS_BEFORE = _utils.LS_BEFORE
LS_AFTER = _utils.LS_AFTER
LS_STOP = _utils.LS_STOP
LS_DELETE = _utils.LS_DELETE

def lsCreate() -> "lsList":
    """lsCreate() -> ls_dummy"""
    return _utils.lsCreate()

def lsSingleton(arg1: 'lsGeneric', arg2: 'lsHandle *') -> "lsList":
    """lsSingleton(lsGeneric arg1, lsHandle * arg2) -> ls_dummy"""
    return _utils.lsSingleton(arg1, arg2)

def lsDestroy(arg1: 'ls_dummy', arg2: 'void (*)()') -> "lsStatus":
    """lsDestroy(ls_dummy arg1, void (*)() arg2) -> lsStatus"""
    return _utils.lsDestroy(arg1, arg2)

def lsDestroyListList(arg1: 'ls_dummy') -> "lsStatus":
    """lsDestroyListList(ls_dummy arg1) -> lsStatus"""
    return _utils.lsDestroyListList(arg1)

def lsCopy(arg1: 'ls_dummy', arg2: 'LS_PFLSG') -> "lsList":
    """lsCopy(ls_dummy arg1, LS_PFLSG arg2) -> ls_dummy"""
    return _utils.lsCopy(arg1, arg2)

def lsCopyListList(arg1: 'ls_dummy') -> "lsList":
    """lsCopyListList(ls_dummy arg1) -> ls_dummy"""
    return _utils.lsCopyListList(arg1)

def lsAppend(arg1: 'ls_dummy', arg2: 'ls_dummy', arg3: 'LS_PFLSG') -> "lsList":
    """lsAppend(ls_dummy arg1, ls_dummy arg2, LS_PFLSG arg3) -> ls_dummy"""
    return _utils.lsAppend(arg1, arg2, arg3)

def lsJoin(arg1: 'ls_dummy', arg2: 'ls_dummy', arg3: 'LS_PFLSG') -> "void":
    """lsJoin(ls_dummy arg1, ls_dummy arg2, LS_PFLSG arg3)"""
    return _utils.lsJoin(arg1, arg2, arg3)

def lsFirstItem(arg1: 'ls_dummy', arg2: 'lsGeneric *', arg3: 'lsHandle *') -> "lsStatus":
    """lsFirstItem(ls_dummy arg1, lsGeneric * arg2, lsHandle * arg3) -> lsStatus"""
    return _utils.lsFirstItem(arg1, arg2, arg3)

def lsLastItem(arg1: 'ls_dummy', arg2: 'lsGeneric *', arg3: 'lsHandle *') -> "lsStatus":
    """lsLastItem(ls_dummy arg1, lsGeneric * arg2, lsHandle * arg3) -> lsStatus"""
    return _utils.lsLastItem(arg1, arg2, arg3)

def lsNewBegin(arg1: 'ls_dummy', arg2: 'lsGeneric', arg3: 'lsHandle *') -> "lsStatus":
    """lsNewBegin(ls_dummy arg1, lsGeneric arg2, lsHandle * arg3) -> lsStatus"""
    return _utils.lsNewBegin(arg1, arg2, arg3)

def lsNewEnd(arg1: 'ls_dummy', arg2: 'lsGeneric', arg3: 'lsHandle *') -> "lsStatus":
    """lsNewEnd(ls_dummy arg1, lsGeneric arg2, lsHandle * arg3) -> lsStatus"""
    return _utils.lsNewEnd(arg1, arg2, arg3)

def lsDelBegin(arg1: 'ls_dummy', arg2: 'lsGeneric *') -> "lsStatus":
    """lsDelBegin(ls_dummy arg1, lsGeneric * arg2) -> lsStatus"""
    return _utils.lsDelBegin(arg1, arg2)

def lsDelEnd(arg1: 'ls_dummy', arg2: 'lsGeneric *') -> "lsStatus":
    """lsDelEnd(ls_dummy arg1, lsGeneric * arg2) -> lsStatus"""
    return _utils.lsDelEnd(arg1, arg2)

def lsLength(arg1: 'ls_dummy') -> "int":
    """lsLength(ls_dummy arg1) -> int"""
    return _utils.lsLength(arg1)

def lsStart(arg1: 'ls_dummy') -> "lsGen":
    """lsStart(ls_dummy arg1) -> ls_dummy"""
    return _utils.lsStart(arg1)

def lsEnd(arg1: 'ls_dummy') -> "lsGen":
    """lsEnd(ls_dummy arg1) -> ls_dummy"""
    return _utils.lsEnd(arg1)

def lsGenHandle(arg1: 'ls_dummy', arg2: 'lsGeneric *', arg3: 'int') -> "lsGen":
    """lsGenHandle(ls_dummy arg1, lsGeneric * arg2, int arg3) -> ls_dummy"""
    return _utils.lsGenHandle(arg1, arg2, arg3)

def lsNext(arg1: 'ls_dummy', arg2: 'lsGeneric *', arg3: 'lsHandle *') -> "lsStatus":
    """lsNext(ls_dummy arg1, lsGeneric * arg2, lsHandle * arg3) -> lsStatus"""
    return _utils.lsNext(arg1, arg2, arg3)

def lsPrev(arg1: 'ls_dummy', arg2: 'lsGeneric *', arg3: 'lsHandle *') -> "lsStatus":
    """lsPrev(ls_dummy arg1, lsGeneric * arg2, lsHandle * arg3) -> lsStatus"""
    return _utils.lsPrev(arg1, arg2, arg3)

def lsInBefore(arg1: 'ls_dummy', arg2: 'lsGeneric', arg3: 'lsHandle *') -> "lsStatus":
    """lsInBefore(ls_dummy arg1, lsGeneric arg2, lsHandle * arg3) -> lsStatus"""
    return _utils.lsInBefore(arg1, arg2, arg3)

def lsInAfter(arg1: 'ls_dummy', arg2: 'lsGeneric', arg3: 'lsHandle *') -> "lsStatus":
    """lsInAfter(ls_dummy arg1, lsGeneric arg2, lsHandle * arg3) -> lsStatus"""
    return _utils.lsInAfter(arg1, arg2, arg3)

def lsDelBefore(arg1: 'ls_dummy', arg2: 'lsGeneric *') -> "lsStatus":
    """lsDelBefore(ls_dummy arg1, lsGeneric * arg2) -> lsStatus"""
    return _utils.lsDelBefore(arg1, arg2)

def lsDelAfter(arg1: 'ls_dummy', arg2: 'lsGeneric *') -> "lsStatus":
    """lsDelAfter(ls_dummy arg1, lsGeneric * arg2) -> lsStatus"""
    return _utils.lsDelAfter(arg1, arg2)

def lsFinish(arg1: 'ls_dummy') -> "lsStatus":
    """lsFinish(ls_dummy arg1) -> lsStatus"""
    return _utils.lsFinish(arg1)

def lsQueryHandle(arg1: 'ls_dummy') -> "lsList":
    """lsQueryHandle(ls_dummy arg1) -> ls_dummy"""
    return _utils.lsQueryHandle(arg1)

def lsFetchHandle(arg1: 'ls_dummy') -> "lsGeneric":
    """lsFetchHandle(ls_dummy arg1) -> lsGeneric"""
    return _utils.lsFetchHandle(arg1)

def lsRemoveItem(arg1: 'ls_dummy', arg2: 'lsGeneric *') -> "lsStatus":
    """lsRemoveItem(ls_dummy arg1, lsGeneric * arg2) -> lsStatus"""
    return _utils.lsRemoveItem(arg1, arg2)

def lsSort(arg1: 'ls_dummy', arg2: 'int (*)()') -> "lsStatus":
    """lsSort(ls_dummy arg1, int (*)() arg2) -> lsStatus"""
    return _utils.lsSort(arg1, arg2)

def lsUniq(arg1: 'ls_dummy', arg2: 'int (*)()', arg3: 'void (*)()') -> "lsStatus":
    """lsUniq(ls_dummy arg1, int (*)() arg2, void (*)() arg3) -> lsStatus"""
    return _utils.lsUniq(arg1, arg2, arg3)

def NodeGraph_create() -> "NodeGraph_ptr":
    """NodeGraph_create() -> NodeGraph_ptr"""
    return _utils.NodeGraph_create()

def NodeGraph_destroy(arg1: 'NodeGraph_ptr') -> "void":
    """NodeGraph_destroy(NodeGraph_ptr arg1)"""
    return _utils.NodeGraph_destroy(arg1)

def NodeGraph_add_children(arg1: 'NodeGraph_ptr', var: 'node_ptr', children: 'Set_t const') -> "void":
    """NodeGraph_add_children(NodeGraph_ptr arg1, node_ptr var, Set_t const children)"""
    return _utils.NodeGraph_add_children(arg1, var, children)

def NodeGraph_remove_nodes(arg1: 'NodeGraph_ptr', nodes: 'Set_t const') -> "void":
    """NodeGraph_remove_nodes(NodeGraph_ptr arg1, Set_t const nodes)"""
    return _utils.NodeGraph_remove_nodes(arg1, nodes)

def NodeGraph_clear_removed_nodes(arg1: 'NodeGraph_ptr') -> "void":
    """NodeGraph_clear_removed_nodes(NodeGraph_ptr arg1)"""
    return _utils.NodeGraph_clear_removed_nodes(arg1)

def NodeGraph_is_empty(arg1: 'NodeGraph_ptr const') -> "boolean":
    """NodeGraph_is_empty(NodeGraph_ptr const arg1) -> boolean"""
    return _utils.NodeGraph_is_empty(arg1)

def NodeGraph_get_leaves(arg1: 'NodeGraph_ptr const') -> "Set_t":
    """NodeGraph_get_leaves(NodeGraph_ptr const arg1) -> Set_t"""
    return _utils.NodeGraph_get_leaves(arg1)

def NodeGraph_get_parents(arg1: 'NodeGraph_ptr const', child: 'node_ptr') -> "Set_t":
    """NodeGraph_get_parents(NodeGraph_ptr const arg1, node_ptr child) -> Set_t"""
    return _utils.NodeGraph_get_parents(arg1, child)

def NodeGraph_print(arg1: 'NodeGraph_ptr const', out: 'FILE *') -> "void":
    """NodeGraph_print(NodeGraph_ptr const arg1, FILE * out)"""
    return _utils.NodeGraph_print(arg1, out)

def NodeList_create() -> "NodeList_ptr":
    """NodeList_create() -> NodeList_ptr"""
    return _utils.NodeList_create()

def NodeList_create_from_list(list: 'node_ptr') -> "NodeList_ptr":
    """NodeList_create_from_list(node_ptr list) -> NodeList_ptr"""
    return _utils.NodeList_create_from_list(list)

def NodeList_destroy(arg1: 'NodeList_ptr') -> "void":
    """NodeList_destroy(NodeList_ptr arg1)"""
    return _utils.NodeList_destroy(arg1)

def NodeList_copy(arg1: 'NodeList_ptr') -> "NodeList_ptr":
    """NodeList_copy(NodeList_ptr arg1) -> NodeList_ptr"""
    return _utils.NodeList_copy(arg1)

def NodeList_append(arg1: 'NodeList_ptr', elem: 'node_ptr') -> "void":
    """NodeList_append(NodeList_ptr arg1, node_ptr elem)"""
    return _utils.NodeList_append(arg1, elem)

def NodeList_prepend(arg1: 'NodeList_ptr', elem: 'node_ptr') -> "void":
    """NodeList_prepend(NodeList_ptr arg1, node_ptr elem)"""
    return _utils.NodeList_prepend(arg1, elem)

def NodeList_insert_before(arg1: 'NodeList_ptr', iter: 'ListIter_ptr', elem: 'node_ptr') -> "void":
    """NodeList_insert_before(NodeList_ptr arg1, ListIter_ptr iter, node_ptr elem)"""
    return _utils.NodeList_insert_before(arg1, iter, elem)

def NodeList_insert_after(arg1: 'NodeList_ptr', iter: 'ListIter_ptr', elem: 'node_ptr') -> "void":
    """NodeList_insert_after(NodeList_ptr arg1, ListIter_ptr iter, node_ptr elem)"""
    return _utils.NodeList_insert_after(arg1, iter, elem)

def NodeList_remove_elem_at(arg1: 'NodeList_ptr', iter: 'ListIter_ptr') -> "node_ptr":
    """NodeList_remove_elem_at(NodeList_ptr arg1, ListIter_ptr iter) -> node_ptr"""
    return _utils.NodeList_remove_elem_at(arg1, iter)

def NodeList_remove_elems(arg1: 'NodeList_ptr', other: 'NodeList_ptr const', disposer: 'NodeListPred', disposer_arg: 'void *') -> "int":
    """NodeList_remove_elems(NodeList_ptr arg1, NodeList_ptr const other, NodeListPred disposer, void * disposer_arg) -> int"""
    return _utils.NodeList_remove_elems(arg1, other, disposer, disposer_arg)

def NodeList_get_length(arg1: 'NodeList_ptr const') -> "int":
    """NodeList_get_length(NodeList_ptr const arg1) -> int"""
    return _utils.NodeList_get_length(arg1)

def NodeList_reverse(arg1: 'NodeList_ptr') -> "void":
    """NodeList_reverse(NodeList_ptr arg1)"""
    return _utils.NodeList_reverse(arg1)

def NodeList_concat(arg1: 'NodeList_ptr', src: 'NodeList_ptr const') -> "void":
    """NodeList_concat(NodeList_ptr arg1, NodeList_ptr const src)"""
    return _utils.NodeList_concat(arg1, src)

def NodeList_concat_unique(arg1: 'NodeList_ptr', src: 'NodeList_ptr const') -> "void":
    """NodeList_concat_unique(NodeList_ptr arg1, NodeList_ptr const src)"""
    return _utils.NodeList_concat_unique(arg1, src)

def NodeList_belongs_to(arg1: 'NodeList_ptr const', elem: 'node_ptr') -> "boolean":
    """NodeList_belongs_to(NodeList_ptr const arg1, node_ptr elem) -> boolean"""
    return _utils.NodeList_belongs_to(arg1, elem)

def NodeList_search(arg1: 'NodeList_ptr const', pred: 'NodeListPred', arg: 'void *') -> "ListIter_ptr":
    """NodeList_search(NodeList_ptr const arg1, NodeListPred pred, void * arg) -> ListIter_ptr"""
    return _utils.NodeList_search(arg1, pred, arg)

def NodeList_count_elem(arg1: 'NodeList_ptr const', elem: 'node_ptr') -> "int":
    """NodeList_count_elem(NodeList_ptr const arg1, node_ptr elem) -> int"""
    return _utils.NodeList_count_elem(arg1, elem)

def NodeList_get_first_iter(arg1: 'NodeList_ptr const') -> "ListIter_ptr":
    """NodeList_get_first_iter(NodeList_ptr const arg1) -> ListIter_ptr"""
    return _utils.NodeList_get_first_iter(arg1)

def NodeList_get_elem_at(arg1: 'NodeList_ptr const', iter: 'ListIter_ptr const') -> "node_ptr":
    """NodeList_get_elem_at(NodeList_ptr const arg1, ListIter_ptr const iter) -> node_ptr"""
    return _utils.NodeList_get_elem_at(arg1, iter)

def NodeList_foreach(arg1: 'NodeList_ptr', foo: 'NODE_LIST_FOREACH_FUN_P', user_data: 'void *') -> "int":
    """NodeList_foreach(NodeList_ptr arg1, NODE_LIST_FOREACH_FUN_P foo, void * user_data) -> int"""
    return _utils.NodeList_foreach(arg1, foo, user_data)

def NodeList_map(arg1: 'NodeList_ptr const', foo: 'NPFN') -> "NodeList_ptr":
    """NodeList_map(NodeList_ptr const arg1, NPFN foo) -> NodeList_ptr"""
    return _utils.NodeList_map(arg1, foo)

def NodeList_filter(arg1: 'NodeList_ptr const', foo: 'BPFN') -> "NodeList_ptr":
    """NodeList_filter(NodeList_ptr const arg1, BPFN foo) -> NodeList_ptr"""
    return _utils.NodeList_filter(arg1, foo)

def ListIter_get_next(arg1: 'ListIter_ptr const') -> "ListIter_ptr":
    """ListIter_get_next(ListIter_ptr const arg1) -> ListIter_ptr"""
    return _utils.ListIter_get_next(arg1)

def ListIter_is_end(arg1: 'ListIter_ptr const') -> "boolean":
    """ListIter_is_end(ListIter_ptr const arg1) -> boolean"""
    return _utils.ListIter_is_end(arg1)

def ListIter_get_end() -> "ListIter_ptr":
    """ListIter_get_end() -> ListIter_ptr"""
    return _utils.ListIter_get_end()

def NodeList_print_nodes(arg1: 'NodeList_ptr const', out: 'FILE *') -> "void":
    """NodeList_print_nodes(NodeList_ptr const arg1, FILE * out)"""
    return _utils.NodeList_print_nodes(arg1, out)

def Object_destroy(arg1: 'Object_ptr', arg: 'void *') -> "void":
    """Object_destroy(Object_ptr arg1, void * arg)"""
    return _utils.Object_destroy(arg1, arg)

def Object_copy(arg1: 'Object_ptr const') -> "Object_ptr":
    """Object_copy(Object_ptr const arg1) -> Object_ptr"""
    return _utils.Object_copy(arg1)
class Oiter(_object):
    """Proxy of C Oiter_TAG struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Oiter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Oiter, name)
    __repr__ = _swig_repr
    __swig_setmethods__["node"] = _utils.Oiter_node_set
    __swig_getmethods__["node"] = _utils.Oiter_node_get
    if _newclass:
        node = _swig_property(_utils.Oiter_node_get, _utils.Oiter_node_set)

    def __init__(self):
        """__init__(Oiter_TAG self) -> Oiter"""
        this = _utils.new_Oiter()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _utils.delete_Oiter
    __del__ = lambda self: None
Oiter_swigregister = _utils.Oiter_swigregister
Oiter_swigregister(Oiter)


def Olist_create() -> "Olist_ptr":
    """Olist_create() -> Olist_ptr"""
    return _utils.Olist_create()

def Olist_destroy(arg1: 'Olist_ptr') -> "void":
    """Olist_destroy(Olist_ptr arg1)"""
    return _utils.Olist_destroy(arg1)

def Olist_copy(arg1: 'Olist_ptr') -> "Olist_ptr":
    """Olist_copy(Olist_ptr arg1) -> Olist_ptr"""
    return _utils.Olist_copy(arg1)

def Olist_copy_reversed(arg1: 'Olist_ptr') -> "Olist_ptr":
    """Olist_copy_reversed(Olist_ptr arg1) -> Olist_ptr"""
    return _utils.Olist_copy_reversed(arg1)

def Olist_copy_without_element(arg1: 'Olist_ptr', element: 'void *') -> "Olist_ptr":
    """Olist_copy_without_element(Olist_ptr arg1, void * element) -> Olist_ptr"""
    return _utils.Olist_copy_without_element(arg1, element)

def Olist_reverse(arg1: 'Olist_ptr') -> "void":
    """Olist_reverse(Olist_ptr arg1)"""
    return _utils.Olist_reverse(arg1)

def Olist_move(arg1: 'Olist_ptr', to_list: 'Olist_ptr', iter_to: 'Oiter') -> "void":
    """Olist_move(Olist_ptr arg1, Olist_ptr to_list, Oiter iter_to)"""
    return _utils.Olist_move(arg1, to_list, iter_to)

def Olist_move_all(arg1: 'Olist_ptr', to_list: 'Olist_ptr') -> "void":
    """Olist_move_all(Olist_ptr arg1, Olist_ptr to_list)"""
    return _utils.Olist_move_all(arg1, to_list)

def Olist_clean(arg1: 'Olist_ptr') -> "void":
    """Olist_clean(Olist_ptr arg1)"""
    return _utils.Olist_clean(arg1)

def Olist_prepend(arg1: 'Olist_ptr', element: 'void *') -> "void":
    """Olist_prepend(Olist_ptr arg1, void * element)"""
    return _utils.Olist_prepend(arg1, element)

def Olist_append(arg1: 'Olist_ptr', element: 'void *') -> "void":
    """Olist_append(Olist_ptr arg1, void * element)"""
    return _utils.Olist_append(arg1, element)

def Olist_delete_first(arg1: 'Olist_ptr') -> "void *":
    """Olist_delete_first(Olist_ptr arg1) -> void *"""
    return _utils.Olist_delete_first(arg1)

def Olist_get_size(arg1: 'Olist_ptr const') -> "int":
    """Olist_get_size(Olist_ptr const arg1) -> int"""
    return _utils.Olist_get_size(arg1)

def Olist_is_empty(arg1: 'Olist_ptr') -> "boolean":
    """Olist_is_empty(Olist_ptr arg1) -> boolean"""
    return _utils.Olist_is_empty(arg1)

def Olist_first(arg1: 'Olist_ptr') -> "Oiter":
    """Olist_first(Olist_ptr arg1) -> Oiter"""
    return _utils.Olist_first(arg1)

def Olist_last(arg1: 'Olist_ptr') -> "Oiter":
    """Olist_last(Olist_ptr arg1) -> Oiter"""
    return _utils.Olist_last(arg1)

def Oiter_make_end(iter: 'Oiter') -> "void":
    """Oiter_make_end(Oiter iter)"""
    return _utils.Oiter_make_end(iter)

def Oiter_is_end(iter: 'Oiter') -> "boolean":
    """Oiter_is_end(Oiter iter) -> boolean"""
    return _utils.Oiter_is_end(iter)

def Oiter_next(iter: 'Oiter') -> "Oiter":
    """Oiter_next(Oiter iter) -> Oiter"""
    return _utils.Oiter_next(iter)

def Oiter_element(iter: 'Oiter') -> "void *":
    """Oiter_element(Oiter iter) -> void *"""
    return _utils.Oiter_element(iter)

def Oiter_set_element(iter: 'Oiter', element: 'void *') -> "void":
    """Oiter_set_element(Oiter iter, void * element)"""
    return _utils.Oiter_set_element(iter, element)

def Olist_insert_after(arg1: 'Olist_ptr', iter: 'Oiter', element: 'void *') -> "Oiter":
    """Olist_insert_after(Olist_ptr arg1, Oiter iter, void * element) -> Oiter"""
    return _utils.Olist_insert_after(arg1, iter, element)

def Olist_insert_before(arg1: 'Olist_ptr', iter: 'Oiter', element: 'void *') -> "Oiter":
    """Olist_insert_before(Olist_ptr arg1, Oiter iter, void * element) -> Oiter"""
    return _utils.Olist_insert_before(arg1, iter, element)

def Olist_delete(arg1: 'Olist_ptr', iter: 'Oiter', element: 'void **') -> "Oiter":
    """Olist_delete(Olist_ptr arg1, Oiter iter, void ** element) -> Oiter"""
    return _utils.Olist_delete(arg1, iter, element)

def Olist_iter_is_first(arg1: 'Olist_ptr', iter: 'Oiter') -> "boolean":
    """Olist_iter_is_first(Olist_ptr arg1, Oiter iter) -> boolean"""
    return _utils.Olist_iter_is_first(arg1, iter)

def Olist_iter_is_last(arg1: 'Olist_ptr', iter: 'Oiter') -> "boolean":
    """Olist_iter_is_last(Olist_ptr arg1, Oiter iter) -> boolean"""
    return _utils.Olist_iter_is_last(arg1, iter)

def Olist_contains(arg1: 'Olist_ptr const', element: 'void const *') -> "boolean":
    """Olist_contains(Olist_ptr const arg1, void const * element) -> boolean"""
    return _utils.Olist_contains(arg1, element)

def Olist_remove(arg1: 'Olist_ptr', element: 'void const *') -> "boolean":
    """Olist_remove(Olist_ptr arg1, void const * element) -> boolean"""
    return _utils.Olist_remove(arg1, element)

def Olist_sort(arg1: 'Olist_ptr', cmp: 'int (*)(void *,void *)') -> "void":
    """Olist_sort(Olist_ptr arg1, int (*)(void *,void *) cmp)"""
    return _utils.Olist_sort(arg1, cmp)

def Olist_print_node(arg1: 'Olist_ptr', output: 'FILE *') -> "void":
    """Olist_print_node(Olist_ptr arg1, FILE * output)"""
    return _utils.Olist_print_node(arg1, output)
class Pair(_object):
    """Proxy of C Pair_TAG struct."""

    __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
    __swig_setmethods__["first"] = _utils.Pair_first_set
    __swig_getmethods__["first"] = _utils.Pair_first_get
    if _newclass:
        first = _swig_property(_utils.Pair_first_get, _utils.Pair_first_set)
    __swig_setmethods__["second"] = _utils.Pair_second_set
    __swig_getmethods__["second"] = _utils.Pair_second_get
    if _newclass:
        second = _swig_property(_utils.Pair_second_get, _utils.Pair_second_set)
    __swig_setmethods__["frozen"] = _utils.Pair_frozen_set
    __swig_getmethods__["frozen"] = _utils.Pair_frozen_get
    if _newclass:
        frozen = _swig_property(_utils.Pair_frozen_get, _utils.Pair_frozen_set)

    def __init__(self):
        """__init__(Pair_TAG self) -> Pair"""
        this = _utils.new_Pair()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _utils.delete_Pair
    __del__ = lambda self: None
Pair_swigregister = _utils.Pair_swigregister
Pair_swigregister(Pair)


def Pair_create(first: 'void *', second: 'void *') -> "Pair_ptr":
    """Pair_create(void * first, void * second) -> Pair"""
    return _utils.Pair_create(first, second)

def Pair_freeze(arg1: 'Pair') -> "void":
    """Pair_freeze(Pair arg1)"""
    return _utils.Pair_freeze(arg1)

def Pair_is_freezed(arg1: 'Pair') -> "boolean":
    """Pair_is_freezed(Pair arg1) -> boolean"""
    return _utils.Pair_is_freezed(arg1)

def Pair_get_first(arg1: 'Pair') -> "void *":
    """Pair_get_first(Pair arg1) -> void *"""
    return _utils.Pair_get_first(arg1)

def Pair_get_second(arg1: 'Pair') -> "void *":
    """Pair_get_second(Pair arg1) -> void *"""
    return _utils.Pair_get_second(arg1)

def Pair_set_first(arg1: 'Pair', first: 'void *') -> "void":
    """Pair_set_first(Pair arg1, void * first)"""
    return _utils.Pair_set_first(arg1, first)

def Pair_set_second(arg1: 'Pair', second: 'void *') -> "void":
    """Pair_set_second(Pair arg1, void * second)"""
    return _utils.Pair_set_second(arg1, second)

def Pair_set_values(arg1: 'Pair', first: 'void *', second: 'void *') -> "void":
    """Pair_set_values(Pair arg1, void * first, void * second)"""
    return _utils.Pair_set_values(arg1, first, second)

def Pair_destroy(arg1: 'Pair') -> "void":
    """Pair_destroy(Pair arg1)"""
    return _utils.Pair_destroy(arg1)

def Pair_compare(a: 'Pair', b: 'Pair') -> "int":
    """Pair_compare(Pair a, Pair b) -> int"""
    return _utils.Pair_compare(a, b)

def Pair_hash(arg1: 'Pair', size: 'int') -> "int":
    """Pair_hash(Pair arg1, int size) -> int"""
    return _utils.Pair_hash(arg1, size)

def malloc(arg1: 'size_t') -> "void *":
    """malloc(size_t arg1) -> void *"""
    return _utils.malloc(arg1)

def realloc(arg1: 'void *', arg2: 'size_t') -> "void *":
    """realloc(void * arg1, size_t arg2) -> void *"""
    return _utils.realloc(arg1, arg2)
ERANGE = _utils.ERANGE
EINVAL = _utils.EINVAL

def Utils_set_data_for_range_check(var: 'node_ptr', range: 'node_ptr') -> "void":
    """Utils_set_data_for_range_check(node_ptr var, node_ptr range)"""
    return _utils.Utils_set_data_for_range_check(var, range)

def Utils_set_mode_for_range_check(is_fatal: 'boolean') -> "void":
    """Utils_set_mode_for_range_check(boolean is_fatal)"""
    return _utils.Utils_set_mode_for_range_check(is_fatal)

def Utils_range_check(n: 'node_ptr') -> "void":
    """Utils_range_check(node_ptr n)"""
    return _utils.Utils_range_check(n)

def Utils_failure_node_check(n: 'node_ptr') -> "void":
    """Utils_failure_node_check(node_ptr n)"""
    return _utils.Utils_failure_node_check(n)

def Utils_is_in_range(s: 'node_ptr', d: 'node_ptr') -> "boolean":
    """Utils_is_in_range(node_ptr s, node_ptr d) -> boolean"""
    return _utils.Utils_is_in_range(s, d)

def Utils_check_subrange(subrange: 'node_ptr') -> "boolean":
    """Utils_check_subrange(node_ptr subrange) -> boolean"""
    return _utils.Utils_check_subrange(subrange)

def Utils_check_subrange_not_negative(subrange: 'node_ptr') -> "boolean":
    """Utils_check_subrange_not_negative(node_ptr subrange) -> boolean"""
    return _utils.Utils_check_subrange_not_negative(subrange)
class Siter(_object):
    """Proxy of C Siter_TAG struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Siter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Siter, name)
    __repr__ = _swig_repr
    __swig_setmethods__["node"] = _utils.Siter_node_set
    __swig_getmethods__["node"] = _utils.Siter_node_get
    if _newclass:
        node = _swig_property(_utils.Siter_node_get, _utils.Siter_node_set)

    def __init__(self):
        """__init__(Siter_TAG self) -> Siter"""
        this = _utils.new_Siter()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _utils.delete_Siter
    __del__ = lambda self: None
Siter_swigregister = _utils.Siter_swigregister
Siter_swigregister(Siter)


def Slist_create() -> "Slist_ptr":
    """Slist_create() -> Slist_ptr"""
    return _utils.Slist_create()

def Slist_destroy(arg1: 'Slist_ptr') -> "void":
    """Slist_destroy(Slist_ptr arg1)"""
    return _utils.Slist_destroy(arg1)

def Slist_destroy_and_free_elements(arg1: 'Slist_ptr', f: 'Slist_free_function') -> "void":
    """Slist_destroy_and_free_elements(Slist_ptr arg1, Slist_free_function f)"""
    return _utils.Slist_destroy_and_free_elements(arg1, f)

def Slist_copy(arg1: 'Slist_ptr') -> "Slist_ptr":
    """Slist_copy(Slist_ptr arg1) -> Slist_ptr"""
    return _utils.Slist_copy(arg1)

def Slist_copy_reversed(arg1: 'Slist_ptr') -> "Slist_ptr":
    """Slist_copy_reversed(Slist_ptr arg1) -> Slist_ptr"""
    return _utils.Slist_copy_reversed(arg1)

def Slist_reverse(arg1: 'Slist_ptr') -> "void":
    """Slist_reverse(Slist_ptr arg1)"""
    return _utils.Slist_reverse(arg1)

def Slist_push(arg1: 'Slist_ptr', element: 'void *') -> "void":
    """Slist_push(Slist_ptr arg1, void * element)"""
    return _utils.Slist_push(arg1, element)

def Slist_pop(arg1: 'Slist_ptr') -> "void *":
    """Slist_pop(Slist_ptr arg1) -> void *"""
    return _utils.Slist_pop(arg1)

def Slist_top(arg1: 'Slist_ptr') -> "void *":
    """Slist_top(Slist_ptr arg1) -> void *"""
    return _utils.Slist_top(arg1)

def Slist_is_empty(arg1: 'Slist_ptr') -> "boolean":
    """Slist_is_empty(Slist_ptr arg1) -> boolean"""
    return _utils.Slist_is_empty(arg1)

def Slist_first(arg1: 'Slist_ptr') -> "Siter":
    """Slist_first(Slist_ptr arg1) -> Siter"""
    return _utils.Slist_first(arg1)

def Siter_make_end(iter: 'Siter') -> "void":
    """Siter_make_end(Siter iter)"""
    return _utils.Siter_make_end(iter)

def Siter_is_end(iter: 'Siter') -> "boolean":
    """Siter_is_end(Siter iter) -> boolean"""
    return _utils.Siter_is_end(iter)

def Siter_next(iter: 'Siter') -> "Siter":
    """Siter_next(Siter iter) -> Siter"""
    return _utils.Siter_next(iter)

def Siter_element(iter: 'Siter') -> "void *":
    """Siter_element(Siter iter) -> void *"""
    return _utils.Siter_element(iter)

def Slist_find(arg1: 'Slist_ptr', element: 'void const *') -> "Siter":
    """Slist_find(Slist_ptr arg1, void const * element) -> Siter"""
    return _utils.Slist_find(arg1, element)

def Slist_contains(arg1: 'Slist_ptr', element: 'void const *') -> "boolean":
    """Slist_contains(Slist_ptr arg1, void const * element) -> boolean"""
    return _utils.Slist_contains(arg1, element)

def Slist_remove(arg1: 'Slist_ptr', element: 'void const *') -> "boolean":
    """Slist_remove(Slist_ptr arg1, void const * element) -> boolean"""
    return _utils.Slist_remove(arg1, element)

def Slist_append(arg1: 'Slist_ptr', other: 'Slist_ptr const') -> "void":
    """Slist_append(Slist_ptr arg1, Slist_ptr const other)"""
    return _utils.Slist_append(arg1, other)

def Slist_equals(arg1: 'Slist_ptr const', other: 'Slist_ptr const') -> "boolean":
    """Slist_equals(Slist_ptr const arg1, Slist_ptr const other) -> boolean"""
    return _utils.Slist_equals(arg1, other)

def Slist_get_size(arg1: 'Slist_ptr') -> "unsigned int":
    """Slist_get_size(Slist_ptr arg1) -> unsigned int"""
    return _utils.Slist_get_size(arg1)

def Slist_sort(arg1: 'Slist_ptr', cmp: 'int (*)(void *,void *)') -> "void":
    """Slist_sort(Slist_ptr arg1, int (*)(void *,void *) cmp)"""
    return _utils.Slist_sort(arg1, cmp)

def Slist_clear(arg1: 'Slist_ptr') -> "void":
    """Slist_clear(Slist_ptr arg1)"""
    return _utils.Slist_clear(arg1)
class Ssiter(_object):
    """Proxy of C Ssiter_TAG struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Ssiter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Ssiter, name)
    __repr__ = _swig_repr
    __swig_setmethods__["node"] = _utils.Ssiter_node_set
    __swig_getmethods__["node"] = _utils.Ssiter_node_get
    if _newclass:
        node = _swig_property(_utils.Ssiter_node_get, _utils.Ssiter_node_set)

    def __init__(self):
        """__init__(Ssiter_TAG self) -> Ssiter"""
        this = _utils.new_Ssiter()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _utils.delete_Ssiter
    __del__ = lambda self: None
Ssiter_swigregister = _utils.Ssiter_swigregister
Ssiter_swigregister(Ssiter)


def Sset_create() -> "Sset_ptr":
    """Sset_create() -> Sset_ptr"""
    return _utils.Sset_create()

def Sset_destroy(arg1: 'Sset_ptr') -> "void":
    """Sset_destroy(Sset_ptr arg1)"""
    return _utils.Sset_destroy(arg1)

def Sset_copy(arg1: 'Sset_ptr const') -> "Sset_ptr":
    """Sset_copy(Sset_ptr const arg1) -> Sset_ptr"""
    return _utils.Sset_copy(arg1)

def Sset_copy_func(arg1: 'Sset_ptr const', func: 'void *(*)(void *)') -> "Sset_ptr":
    """Sset_copy_func(Sset_ptr const arg1, void *(*)(void *) func) -> Sset_ptr"""
    return _utils.Sset_copy_func(arg1, func)

def Sset_insert(arg1: 'Sset_ptr', key: 'long long', element: 'void *') -> "boolean":
    """Sset_insert(Sset_ptr arg1, long long key, void * element) -> boolean"""
    return _utils.Sset_insert(arg1, key, element)

def Sset_find(arg1: 'Sset_ptr', key: 'long long') -> "Ssiter":
    """Sset_find(Sset_ptr arg1, long long key) -> Ssiter"""
    return _utils.Sset_find(arg1, key)

def Sset_find_le(arg1: 'Sset_ptr', key: 'long long') -> "Ssiter":
    """Sset_find_le(Sset_ptr arg1, long long key) -> Ssiter"""
    return _utils.Sset_find_le(arg1, key)

def Sset_find_ge(arg1: 'Sset_ptr', key: 'long long') -> "Ssiter":
    """Sset_find_ge(Sset_ptr arg1, long long key) -> Ssiter"""
    return _utils.Sset_find_ge(arg1, key)

def Sset_find_insert(arg1: 'Sset_ptr', key: 'long long', is_found: 'boolean *') -> "Ssiter":
    """Sset_find_insert(Sset_ptr arg1, long long key, boolean * is_found) -> Ssiter"""
    return _utils.Sset_find_insert(arg1, key, is_found)

def Sset_delete(arg1: 'Sset_ptr', key: 'long long', is_found: 'boolean *') -> "void *":
    """Sset_delete(Sset_ptr arg1, long long key, boolean * is_found) -> void *"""
    return _utils.Sset_delete(arg1, key, is_found)

def Sset_delete_iter(arg1: 'Sset_ptr', iter: 'Ssiter') -> "void":
    """Sset_delete_iter(Sset_ptr arg1, Ssiter iter)"""
    return _utils.Sset_delete_iter(arg1, iter)

def Sset_get_size(arg1: 'Sset_ptr') -> "size_t":
    """Sset_get_size(Sset_ptr arg1) -> size_t"""
    return _utils.Sset_get_size(arg1)

def Sset_is_empty(arg1: 'Sset_ptr') -> "boolean":
    """Sset_is_empty(Sset_ptr arg1) -> boolean"""
    return _utils.Sset_is_empty(arg1)

def Sset_first(arg1: 'Sset_ptr') -> "Ssiter":
    """Sset_first(Sset_ptr arg1) -> Ssiter"""
    return _utils.Sset_first(arg1)

def Sset_last(arg1: 'Sset_ptr') -> "Ssiter":
    """Sset_last(Sset_ptr arg1) -> Ssiter"""
    return _utils.Sset_last(arg1)

def Ssiter_next(iter: 'Ssiter') -> "Ssiter":
    """Ssiter_next(Ssiter iter) -> Ssiter"""
    return _utils.Ssiter_next(iter)

def Ssiter_prev(iter: 'Ssiter') -> "Ssiter":
    """Ssiter_prev(Ssiter iter) -> Ssiter"""
    return _utils.Ssiter_prev(iter)

def Ssiter_is_valid(iter: 'Ssiter') -> "boolean":
    """Ssiter_is_valid(Ssiter iter) -> boolean"""
    return _utils.Ssiter_is_valid(iter)

def Ssiter_element(iter: 'Ssiter') -> "void *":
    """Ssiter_element(Ssiter iter) -> void *"""
    return _utils.Ssiter_element(iter)

def Ssiter_key(iter: 'Ssiter') -> "long long":
    """Ssiter_key(Ssiter iter) -> long long"""
    return _utils.Ssiter_key(iter)

def Ssiter_set_element(iter: 'Ssiter', element: 'void *') -> "void":
    """Ssiter_set_element(Ssiter iter, void * element)"""
    return _utils.Ssiter_set_element(iter, element)
class Stack_TAG(_object):
    """Proxy of C Stack_TAG struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Stack_TAG, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Stack_TAG, name)
    __repr__ = _swig_repr
    __swig_setmethods__["allocated"] = _utils.Stack_TAG_allocated_set
    __swig_getmethods__["allocated"] = _utils.Stack_TAG_allocated_get
    if _newclass:
        allocated = _swig_property(_utils.Stack_TAG_allocated_get, _utils.Stack_TAG_allocated_set)
    __swig_setmethods__["index"] = _utils.Stack_TAG_index_set
    __swig_getmethods__["index"] = _utils.Stack_TAG_index_get
    if _newclass:
        index = _swig_property(_utils.Stack_TAG_index_get, _utils.Stack_TAG_index_set)
    __swig_setmethods__["array"] = _utils.Stack_TAG_array_set
    __swig_getmethods__["array"] = _utils.Stack_TAG_array_get
    if _newclass:
        array = _swig_property(_utils.Stack_TAG_array_get, _utils.Stack_TAG_array_set)

    def __init__(self):
        """__init__(Stack_TAG self) -> Stack_TAG"""
        this = _utils.new_Stack_TAG()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _utils.delete_Stack_TAG
    __del__ = lambda self: None
Stack_TAG_swigregister = _utils.Stack_TAG_swigregister
Stack_TAG_swigregister(Stack_TAG)


def Stack_create() -> "Stack_ptr":
    """Stack_create() -> Stack_TAG"""
    return _utils.Stack_create()

def Stack_create_with_param(size: 'int') -> "Stack_ptr":
    """Stack_create_with_param(int size) -> Stack_TAG"""
    return _utils.Stack_create_with_param(size)

def Stack_destroy(arg1: 'Stack_TAG') -> "void":
    """Stack_destroy(Stack_TAG arg1)"""
    return _utils.Stack_destroy(arg1)

def Stack_copy(arg1: 'Stack_TAG') -> "Stack_ptr":
    """Stack_copy(Stack_TAG arg1) -> Stack_TAG"""
    return _utils.Stack_copy(arg1)

def Stack_push(arg1: 'Stack_TAG', element: 'void *') -> "void":
    """Stack_push(Stack_TAG arg1, void * element)"""
    return _utils.Stack_push(arg1, element)

def Stack_pop(arg1: 'Stack_TAG') -> "void *":
    """Stack_pop(Stack_TAG arg1) -> void *"""
    return _utils.Stack_pop(arg1)

def Stack_top(arg1: 'Stack_TAG') -> "void *":
    """Stack_top(Stack_TAG arg1) -> void *"""
    return _utils.Stack_top(arg1)

def Stack_is_empty(arg1: 'Stack_TAG') -> "boolean":
    """Stack_is_empty(Stack_TAG arg1) -> boolean"""
    return _utils.Stack_is_empty(arg1)

def Stack_get_size(arg1: 'Stack_TAG') -> "size_t":
    """Stack_get_size(Stack_TAG arg1) -> size_t"""
    return _utils.Stack_get_size(arg1)

def TimerBench_create(name: 'char const *') -> "TimerBench_ptr":
    """TimerBench_create(char const * name) -> TimerBench_ptr"""
    return _utils.TimerBench_create(name)

def TimerBench_destroy(arg1: 'TimerBench_ptr') -> "void":
    """TimerBench_destroy(TimerBench_ptr arg1)"""
    return _utils.TimerBench_destroy(arg1)

def TimerBench_start(arg1: 'TimerBench_ptr') -> "void":
    """TimerBench_start(TimerBench_ptr arg1)"""
    return _utils.TimerBench_start(arg1)

def TimerBench_stop(arg1: 'TimerBench_ptr') -> "void":
    """TimerBench_stop(TimerBench_ptr arg1)"""
    return _utils.TimerBench_stop(arg1)

def TimerBench_reset(arg1: 'TimerBench_ptr') -> "void":
    """TimerBench_reset(TimerBench_ptr arg1)"""
    return _utils.TimerBench_reset(arg1)

def TimerBench_is_running(arg1: 'TimerBench_ptr const') -> "boolean":
    """TimerBench_is_running(TimerBench_ptr const arg1) -> boolean"""
    return _utils.TimerBench_is_running(arg1)

def TimerBench_get_time(arg1: 'TimerBench_ptr const') -> "long":
    """TimerBench_get_time(TimerBench_ptr const arg1) -> long"""
    return _utils.TimerBench_get_time(arg1)

def TimerBench_get_laps(arg1: 'TimerBench_ptr const') -> "long":
    """TimerBench_get_laps(TimerBench_ptr const arg1) -> long"""
    return _utils.TimerBench_get_laps(arg1)

def TimerBench_print(arg1: 'TimerBench_ptr const', file: 'FILE *', msg: 'char const *') -> "void":
    """TimerBench_print(TimerBench_ptr const arg1, FILE * file, char const * msg)"""
    return _utils.TimerBench_print(arg1, file, msg)
class Triple(_object):
    """Proxy of C Triple_TAG struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Triple, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Triple, name)
    __repr__ = _swig_repr
    __swig_setmethods__["first"] = _utils.Triple_first_set
    __swig_getmethods__["first"] = _utils.Triple_first_get
    if _newclass:
        first = _swig_property(_utils.Triple_first_get, _utils.Triple_first_set)
    __swig_setmethods__["second"] = _utils.Triple_second_set
    __swig_getmethods__["second"] = _utils.Triple_second_get
    if _newclass:
        second = _swig_property(_utils.Triple_second_get, _utils.Triple_second_set)
    __swig_setmethods__["third"] = _utils.Triple_third_set
    __swig_getmethods__["third"] = _utils.Triple_third_get
    if _newclass:
        third = _swig_property(_utils.Triple_third_get, _utils.Triple_third_set)
    __swig_setmethods__["frozen"] = _utils.Triple_frozen_set
    __swig_getmethods__["frozen"] = _utils.Triple_frozen_get
    if _newclass:
        frozen = _swig_property(_utils.Triple_frozen_get, _utils.Triple_frozen_set)

    def __init__(self):
        """__init__(Triple_TAG self) -> Triple"""
        this = _utils.new_Triple()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _utils.delete_Triple
    __del__ = lambda self: None
Triple_swigregister = _utils.Triple_swigregister
Triple_swigregister(Triple)


def Triple_create(first: 'void *', second: 'void *', third: 'void *') -> "Triple_ptr":
    """Triple_create(void * first, void * second, void * third) -> Triple"""
    return _utils.Triple_create(first, second, third)

def Triple_freeze(arg1: 'Triple') -> "void":
    """Triple_freeze(Triple arg1)"""
    return _utils.Triple_freeze(arg1)

def Triple_is_freezed(arg1: 'Triple') -> "boolean":
    """Triple_is_freezed(Triple arg1) -> boolean"""
    return _utils.Triple_is_freezed(arg1)

def Triple_get_first(arg1: 'Triple') -> "void *":
    """Triple_get_first(Triple arg1) -> void *"""
    return _utils.Triple_get_first(arg1)

def Triple_get_second(arg1: 'Triple') -> "void *":
    """Triple_get_second(Triple arg1) -> void *"""
    return _utils.Triple_get_second(arg1)

def Triple_get_third(arg1: 'Triple') -> "void *":
    """Triple_get_third(Triple arg1) -> void *"""
    return _utils.Triple_get_third(arg1)

def Triple_set_first(arg1: 'Triple', first: 'void *') -> "void":
    """Triple_set_first(Triple arg1, void * first)"""
    return _utils.Triple_set_first(arg1, first)

def Triple_set_second(arg1: 'Triple', second: 'void *') -> "void":
    """Triple_set_second(Triple arg1, void * second)"""
    return _utils.Triple_set_second(arg1, second)

def Triple_set_third(arg1: 'Triple', third: 'void *') -> "void":
    """Triple_set_third(Triple arg1, void * third)"""
    return _utils.Triple_set_third(arg1, third)

def Triple_set_values(arg1: 'Triple', first: 'void *', second: 'void *', third: 'void *') -> "void":
    """Triple_set_values(Triple arg1, void * first, void * second, void * third)"""
    return _utils.Triple_set_values(arg1, first, second, third)

def Triple_destroy(arg1: 'Triple') -> "void":
    """Triple_destroy(Triple arg1)"""
    return _utils.Triple_destroy(arg1)

def Triple_compare(a: 'Triple', b: 'Triple') -> "int":
    """Triple_compare(Triple a, Triple b) -> int"""
    return _utils.Triple_compare(a, b)

def Triple_hash(arg1: 'Triple', size: 'int') -> "int":
    """Triple_hash(Triple arg1, int size) -> int"""
    return _utils.Triple_hash(arg1, size)
class SubstValue(_object):
    """Proxy of C SubstValue_TAG struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SubstValue, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SubstValue, name)
    __repr__ = _swig_repr
    __swig_setmethods__["type"] = _utils.SubstValue_type_set
    __swig_getmethods__["type"] = _utils.SubstValue_type_get
    if _newclass:
        type = _swig_property(_utils.SubstValue_type_get, _utils.SubstValue_type_set)
    __swig_getmethods__["assign"] = _utils.SubstValue_assign_get
    if _newclass:
        assign = _swig_property(_utils.SubstValue_assign_get)

    def __init__(self):
        """__init__(SubstValue_TAG self) -> SubstValue"""
        this = _utils.new_SubstValue()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _utils.delete_SubstValue
    __del__ = lambda self: None
SubstValue_swigregister = _utils.SubstValue_swigregister
SubstValue_swigregister(SubstValue)
sv_string = _utils.sv_string
sv_integer = _utils.sv_integer
sv_floating = _utils.sv_floating
sv_pointer = _utils.sv_pointer
sv_undef = _utils.sv_undef

class SubstValue_TAG_assign(_object):
    """Proxy of C SubstValue_TAG_assign struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SubstValue_TAG_assign, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SubstValue_TAG_assign, name)
    __repr__ = _swig_repr
    __swig_setmethods__["string"] = _utils.SubstValue_TAG_assign_string_set
    __swig_getmethods__["string"] = _utils.SubstValue_TAG_assign_string_get
    if _newclass:
        string = _swig_property(_utils.SubstValue_TAG_assign_string_get, _utils.SubstValue_TAG_assign_string_set)
    __swig_setmethods__["integer"] = _utils.SubstValue_TAG_assign_integer_set
    __swig_getmethods__["integer"] = _utils.SubstValue_TAG_assign_integer_get
    if _newclass:
        integer = _swig_property(_utils.SubstValue_TAG_assign_integer_get, _utils.SubstValue_TAG_assign_integer_set)
    __swig_setmethods__["floating"] = _utils.SubstValue_TAG_assign_floating_set
    __swig_getmethods__["floating"] = _utils.SubstValue_TAG_assign_floating_get
    if _newclass:
        floating = _swig_property(_utils.SubstValue_TAG_assign_floating_get, _utils.SubstValue_TAG_assign_floating_set)
    __swig_setmethods__["pointer"] = _utils.SubstValue_TAG_assign_pointer_set
    __swig_getmethods__["pointer"] = _utils.SubstValue_TAG_assign_pointer_get
    if _newclass:
        pointer = _swig_property(_utils.SubstValue_TAG_assign_pointer_get, _utils.SubstValue_TAG_assign_pointer_set)

    def __init__(self):
        """__init__(SubstValue_TAG_assign self) -> SubstValue_TAG_assign"""
        this = _utils.new_SubstValue_TAG_assign()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _utils.delete_SubstValue_TAG_assign
    __del__ = lambda self: None
SubstValue_TAG_assign_swigregister = _utils.SubstValue_TAG_assign_swigregister
SubstValue_TAG_assign_swigregister(SubstValue_TAG_assign)

class SubstString(_object):
    """Proxy of C SubstString_TAG struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SubstString, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SubstString, name)
    __repr__ = _swig_repr
    __swig_setmethods__["symbol"] = _utils.SubstString_symbol_set
    __swig_getmethods__["symbol"] = _utils.SubstString_symbol_get
    if _newclass:
        symbol = _swig_property(_utils.SubstString_symbol_get, _utils.SubstString_symbol_set)
    __swig_setmethods__["value"] = _utils.SubstString_value_set
    __swig_getmethods__["value"] = _utils.SubstString_value_get
    if _newclass:
        value = _swig_property(_utils.SubstString_value_get, _utils.SubstString_value_set)
    __swig_setmethods__["format"] = _utils.SubstString_format_set
    __swig_getmethods__["format"] = _utils.SubstString_format_get
    if _newclass:
        format = _swig_property(_utils.SubstString_format_get, _utils.SubstString_format_set)

    def __init__(self):
        """__init__(SubstString_TAG self) -> SubstString"""
        this = _utils.new_SubstString()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _utils.delete_SubstString
    __del__ = lambda self: None
SubstString_swigregister = _utils.SubstString_swigregister
SubstString_swigregister(SubstString)


def apply_string_macro_expansion(subst: 'SubstString', string: 'char *', buf_len: 'size_t') -> "void":
    """apply_string_macro_expansion(SubstString subst, char * string, size_t buf_len)"""
    return _utils.apply_string_macro_expansion(subst, string, buf_len)

def util_str2int(str: 'char const *', value: 'int *') -> "int":
    """util_str2int(char const * str, int * value) -> int"""
    return _utils.util_str2int(str, value)

def util_is_string_null(string: 'char const *') -> "int":
    """util_is_string_null(char const * string) -> int"""
    return _utils.util_is_string_null(string)

def util_str2int_incr(str: 'char const *', endptr: 'char **', out: 'int *') -> "int":
    """util_str2int_incr(char const * str, char ** endptr, int * out) -> int"""
    return _utils.util_str2int_incr(str, endptr, out)
class string_rec(_object):
    """Proxy of C string_ struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, string_rec, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, string_rec, name)
    __repr__ = _swig_repr
    __swig_setmethods__["link"] = _utils.string_rec_link_set
    __swig_getmethods__["link"] = _utils.string_rec_link_get
    if _newclass:
        link = _swig_property(_utils.string_rec_link_get, _utils.string_rec_link_set)
    __swig_setmethods__["text"] = _utils.string_rec_text_set
    __swig_getmethods__["text"] = _utils.string_rec_text_get
    if _newclass:
        text = _swig_property(_utils.string_rec_text_get, _utils.string_rec_text_set)

    def __init__(self):
        """__init__(string_ self) -> string_rec"""
        this = _utils.new_string_rec()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _utils.delete_string_rec
    __del__ = lambda self: None
string_rec_swigregister = _utils.string_rec_swigregister
string_rec_swigregister(string_rec)


def init_string() -> "void":
    """init_string()"""
    return _utils.init_string()

def quit_string() -> "void":
    """quit_string()"""
    return _utils.quit_string()

def find_string(arg1: 'char *') -> "string_ptr":
    """find_string(char * arg1) -> string_rec"""
    return _utils.find_string(arg1)

def get_text(str: 'string_rec') -> "char *":
    """get_text(string_rec str) -> char *"""
    return _utils.get_text(str)

def inc_indent_size() -> "void":
    """inc_indent_size()"""
    return _utils.inc_indent_size()

def dec_indent_size() -> "void":
    """dec_indent_size()"""
    return _utils.dec_indent_size()

def get_indent_size() -> "int":
    """get_indent_size() -> int"""
    return _utils.get_indent_size()

def reset_indent_size() -> "void":
    """reset_indent_size()"""
    return _utils.reset_indent_size()

def set_indent_size(arg1: 'int') -> "void":
    """set_indent_size(int arg1)"""
    return _utils.set_indent_size(arg1)

def indent(arg1: 'FILE *') -> "void":
    """indent(FILE * arg1)"""
    return _utils.indent(arg1)

def indent_print(arg1: 'FILE *', arg2: 'char const *') -> "void":
    """indent_print(FILE * arg1, char const * arg2)"""
    return _utils.indent_print(arg1, arg2)

def indent_node(arg1: 'FILE *', arg2: 'char *', arg3: 'node_ptr', arg4: 'char *') -> "void":
    """indent_node(FILE * arg1, char * arg2, node_ptr arg3, char * arg4)"""
    return _utils.indent_node(arg1, arg2, arg3, arg4)

def print_in_process(arg1: 'char *', arg2: 'node_ptr') -> "void":
    """print_in_process(char * arg1, node_ptr arg2)"""
    return _utils.print_in_process(arg1, arg2)

def print_invar(arg1: 'FILE *', arg2: 'Prop_ptr') -> "void":
    """print_invar(FILE * arg1, Prop_ptr arg2)"""
    return _utils.print_invar(arg1, arg2)

def WordNumber_max_width() -> "int":
    """WordNumber_max_width() -> int"""
    return _utils.WordNumber_max_width()

def WordNumber_from_string(str: 'char *', base: 'int') -> "WordNumber_ptr":
    """WordNumber_from_string(char * str, int base) -> WordNumber_ptr"""
    return _utils.WordNumber_from_string(str, base)

def WordNumber_from_sized_string(str: 'char *', base: 'int', width: 'int') -> "WordNumber_ptr":
    """WordNumber_from_sized_string(char * str, int base, int width) -> WordNumber_ptr"""
    return _utils.WordNumber_from_sized_string(str, base, width)

def WordNumber_from_parsed_string(str: 'char *', errorString: 'char **') -> "WordNumber_ptr":
    """WordNumber_from_parsed_string(char * str, char ** errorString) -> WordNumber_ptr"""
    return _utils.WordNumber_from_parsed_string(str, errorString)

def WordNumber_from_integer(value: 'WordNumberValue', width: 'int') -> "WordNumber_ptr":
    """WordNumber_from_integer(WordNumberValue value, int width) -> WordNumber_ptr"""
    return _utils.WordNumber_from_integer(value, width)

def WordNumber_from_signed_integer(val: 'WordNumberValue', width: 'int') -> "WordNumber_ptr":
    """WordNumber_from_signed_integer(WordNumberValue val, int width) -> WordNumber_ptr"""
    return _utils.WordNumber_from_signed_integer(val, width)

def WordNumber_normalize(number: 'WordNumber_ptr const') -> "WordNumber_ptr":
    """WordNumber_normalize(WordNumber_ptr const number) -> WordNumber_ptr"""
    return _utils.WordNumber_normalize(number)

def WordNumber_get_unsigned_value(arg1: 'WordNumber_ptr') -> "WordNumberValue":
    """WordNumber_get_unsigned_value(WordNumber_ptr arg1) -> WordNumberValue"""
    return _utils.WordNumber_get_unsigned_value(arg1)

def WordNumber_get_signed_value(arg1: 'WordNumber_ptr') -> "WordNumberValue":
    """WordNumber_get_signed_value(WordNumber_ptr arg1) -> WordNumberValue"""
    return _utils.WordNumber_get_signed_value(arg1)

def WordNumber_get_width(arg1: 'WordNumber_ptr') -> "int":
    """WordNumber_get_width(WordNumber_ptr arg1) -> int"""
    return _utils.WordNumber_get_width(arg1)

def WordNumber_get_bit(arg1: 'WordNumber_ptr', n: 'int') -> "boolean":
    """WordNumber_get_bit(WordNumber_ptr arg1, int n) -> boolean"""
    return _utils.WordNumber_get_bit(arg1, n)

def WordNumber_get_sign(arg1: 'WordNumber_ptr') -> "boolean":
    """WordNumber_get_sign(WordNumber_ptr arg1) -> boolean"""
    return _utils.WordNumber_get_sign(arg1)

def WordNumber_get_parsed_string(arg1: 'WordNumber_ptr') -> "char *":
    """WordNumber_get_parsed_string(WordNumber_ptr arg1) -> char *"""
    return _utils.WordNumber_get_parsed_string(arg1)

def WordNumber_max_unsigned_value(width: 'int') -> "WordNumberValue":
    """WordNumber_max_unsigned_value(int width) -> WordNumberValue"""
    return _utils.WordNumber_max_unsigned_value(width)

def WordNumber_max_signed_value(width: 'int') -> "WordNumberValue":
    """WordNumber_max_signed_value(int width) -> WordNumberValue"""
    return _utils.WordNumber_max_signed_value(width)

def WordNumber_min_signed_value(width: 'int') -> "WordNumberValue":
    """WordNumber_min_signed_value(int width) -> WordNumberValue"""
    return _utils.WordNumber_min_signed_value(width)

def WordNumber_print(output_stream: 'FILE *', arg2: 'WordNumber_ptr', isSigned: 'boolean') -> "int":
    """WordNumber_print(FILE * output_stream, WordNumber_ptr arg2, boolean isSigned) -> int"""
    return _utils.WordNumber_print(output_stream, arg2, isSigned)

def WordNumber_based_print(output_stream: 'FILE *', arg2: 'WordNumber_ptr', base: 'int', isSigned: 'boolean') -> "int":
    """WordNumber_based_print(FILE * output_stream, WordNumber_ptr arg2, int base, boolean isSigned) -> int"""
    return _utils.WordNumber_based_print(output_stream, arg2, base, isSigned)

def WordNumber_to_string(arg1: 'WordNumber_ptr', isSigned: 'boolean') -> "char *":
    """WordNumber_to_string(WordNumber_ptr arg1, boolean isSigned) -> char *"""
    return _utils.WordNumber_to_string(arg1, isSigned)

def WordNumber_to_based_string(arg1: 'WordNumber_ptr', base: 'int', isSigned: 'boolean') -> "char *":
    """WordNumber_to_based_string(WordNumber_ptr arg1, int base, boolean isSigned) -> char *"""
    return _utils.WordNumber_to_based_string(arg1, base, isSigned)

def WordNumber_unary_minus(v1: 'WordNumber_ptr') -> "WordNumber_ptr":
    """WordNumber_unary_minus(WordNumber_ptr v1) -> WordNumber_ptr"""
    return _utils.WordNumber_unary_minus(v1)

def WordNumber_plus(v1: 'WordNumber_ptr', v2: 'WordNumber_ptr') -> "WordNumber_ptr":
    """WordNumber_plus(WordNumber_ptr v1, WordNumber_ptr v2) -> WordNumber_ptr"""
    return _utils.WordNumber_plus(v1, v2)

def WordNumber_minus(v1: 'WordNumber_ptr', v2: 'WordNumber_ptr') -> "WordNumber_ptr":
    """WordNumber_minus(WordNumber_ptr v1, WordNumber_ptr v2) -> WordNumber_ptr"""
    return _utils.WordNumber_minus(v1, v2)

def WordNumber_times(v1: 'WordNumber_ptr', v2: 'WordNumber_ptr') -> "WordNumber_ptr":
    """WordNumber_times(WordNumber_ptr v1, WordNumber_ptr v2) -> WordNumber_ptr"""
    return _utils.WordNumber_times(v1, v2)

def WordNumber_unsigned_divide(v1: 'WordNumber_ptr', v2: 'WordNumber_ptr') -> "WordNumber_ptr":
    """WordNumber_unsigned_divide(WordNumber_ptr v1, WordNumber_ptr v2) -> WordNumber_ptr"""
    return _utils.WordNumber_unsigned_divide(v1, v2)

def WordNumber_signed_divide(v1: 'WordNumber_ptr', v2: 'WordNumber_ptr') -> "WordNumber_ptr":
    """WordNumber_signed_divide(WordNumber_ptr v1, WordNumber_ptr v2) -> WordNumber_ptr"""
    return _utils.WordNumber_signed_divide(v1, v2)

def WordNumber_unsigned_mod(v1: 'WordNumber_ptr', v2: 'WordNumber_ptr') -> "WordNumber_ptr":
    """WordNumber_unsigned_mod(WordNumber_ptr v1, WordNumber_ptr v2) -> WordNumber_ptr"""
    return _utils.WordNumber_unsigned_mod(v1, v2)

def WordNumber_signed_mod(v1: 'WordNumber_ptr', v2: 'WordNumber_ptr') -> "WordNumber_ptr":
    """WordNumber_signed_mod(WordNumber_ptr v1, WordNumber_ptr v2) -> WordNumber_ptr"""
    return _utils.WordNumber_signed_mod(v1, v2)

def WordNumber_is_zero(v: 'WordNumber_ptr') -> "boolean":
    """WordNumber_is_zero(WordNumber_ptr v) -> boolean"""
    return _utils.WordNumber_is_zero(v)

def WordNumber_equal(v1: 'WordNumber_ptr', v2: 'WordNumber_ptr') -> "boolean":
    """WordNumber_equal(WordNumber_ptr v1, WordNumber_ptr v2) -> boolean"""
    return _utils.WordNumber_equal(v1, v2)

def WordNumber_not_equal(v1: 'WordNumber_ptr', v2: 'WordNumber_ptr') -> "boolean":
    """WordNumber_not_equal(WordNumber_ptr v1, WordNumber_ptr v2) -> boolean"""
    return _utils.WordNumber_not_equal(v1, v2)

def WordNumber_unsigned_less(v1: 'WordNumber_ptr', v2: 'WordNumber_ptr') -> "boolean":
    """WordNumber_unsigned_less(WordNumber_ptr v1, WordNumber_ptr v2) -> boolean"""
    return _utils.WordNumber_unsigned_less(v1, v2)

def WordNumber_unsigned_less_or_equal(v1: 'WordNumber_ptr', v2: 'WordNumber_ptr') -> "boolean":
    """WordNumber_unsigned_less_or_equal(WordNumber_ptr v1, WordNumber_ptr v2) -> boolean"""
    return _utils.WordNumber_unsigned_less_or_equal(v1, v2)

def WordNumber_unsigned_greater(v1: 'WordNumber_ptr', v2: 'WordNumber_ptr') -> "boolean":
    """WordNumber_unsigned_greater(WordNumber_ptr v1, WordNumber_ptr v2) -> boolean"""
    return _utils.WordNumber_unsigned_greater(v1, v2)

def WordNumber_unsigned_greater_or_equal(v1: 'WordNumber_ptr', v2: 'WordNumber_ptr') -> "boolean":
    """WordNumber_unsigned_greater_or_equal(WordNumber_ptr v1, WordNumber_ptr v2) -> boolean"""
    return _utils.WordNumber_unsigned_greater_or_equal(v1, v2)

def WordNumber_signed_less(v1: 'WordNumber_ptr', v2: 'WordNumber_ptr') -> "boolean":
    """WordNumber_signed_less(WordNumber_ptr v1, WordNumber_ptr v2) -> boolean"""
    return _utils.WordNumber_signed_less(v1, v2)

def WordNumber_signed_less_or_equal(v1: 'WordNumber_ptr', v2: 'WordNumber_ptr') -> "boolean":
    """WordNumber_signed_less_or_equal(WordNumber_ptr v1, WordNumber_ptr v2) -> boolean"""
    return _utils.WordNumber_signed_less_or_equal(v1, v2)

def WordNumber_signed_greater(v1: 'WordNumber_ptr', v2: 'WordNumber_ptr') -> "boolean":
    """WordNumber_signed_greater(WordNumber_ptr v1, WordNumber_ptr v2) -> boolean"""
    return _utils.WordNumber_signed_greater(v1, v2)

def WordNumber_signed_greater_or_equal(v1: 'WordNumber_ptr', v2: 'WordNumber_ptr') -> "boolean":
    """WordNumber_signed_greater_or_equal(WordNumber_ptr v1, WordNumber_ptr v2) -> boolean"""
    return _utils.WordNumber_signed_greater_or_equal(v1, v2)

def WordNumber_not(v: 'WordNumber_ptr') -> "WordNumber_ptr":
    """WordNumber_not(WordNumber_ptr v) -> WordNumber_ptr"""
    return _utils.WordNumber_not(v)

def WordNumber_and(v1: 'WordNumber_ptr', v2: 'WordNumber_ptr') -> "WordNumber_ptr":
    """WordNumber_and(WordNumber_ptr v1, WordNumber_ptr v2) -> WordNumber_ptr"""
    return _utils.WordNumber_and(v1, v2)

def WordNumber_or(v1: 'WordNumber_ptr', v2: 'WordNumber_ptr') -> "WordNumber_ptr":
    """WordNumber_or(WordNumber_ptr v1, WordNumber_ptr v2) -> WordNumber_ptr"""
    return _utils.WordNumber_or(v1, v2)

def WordNumber_xor(v1: 'WordNumber_ptr', v2: 'WordNumber_ptr') -> "WordNumber_ptr":
    """WordNumber_xor(WordNumber_ptr v1, WordNumber_ptr v2) -> WordNumber_ptr"""
    return _utils.WordNumber_xor(v1, v2)

def WordNumber_xnor(v1: 'WordNumber_ptr', v2: 'WordNumber_ptr') -> "WordNumber_ptr":
    """WordNumber_xnor(WordNumber_ptr v1, WordNumber_ptr v2) -> WordNumber_ptr"""
    return _utils.WordNumber_xnor(v1, v2)

def WordNumber_implies(v1: 'WordNumber_ptr', v2: 'WordNumber_ptr') -> "WordNumber_ptr":
    """WordNumber_implies(WordNumber_ptr v1, WordNumber_ptr v2) -> WordNumber_ptr"""
    return _utils.WordNumber_implies(v1, v2)

def WordNumber_iff(v1: 'WordNumber_ptr', v2: 'WordNumber_ptr') -> "WordNumber_ptr":
    """WordNumber_iff(WordNumber_ptr v1, WordNumber_ptr v2) -> WordNumber_ptr"""
    return _utils.WordNumber_iff(v1, v2)

def WordNumber_concatenate(v1: 'WordNumber_ptr', v2: 'WordNumber_ptr') -> "WordNumber_ptr":
    """WordNumber_concatenate(WordNumber_ptr v1, WordNumber_ptr v2) -> WordNumber_ptr"""
    return _utils.WordNumber_concatenate(v1, v2)

def WordNumber_bit_select(v: 'WordNumber_ptr', highBit: 'int', lowBit: 'int') -> "WordNumber_ptr":
    """WordNumber_bit_select(WordNumber_ptr v, int highBit, int lowBit) -> WordNumber_ptr"""
    return _utils.WordNumber_bit_select(v, highBit, lowBit)

def WordNumber_unsigned_right_shift(v: 'WordNumber_ptr', numberOfBits: 'int') -> "WordNumber_ptr":
    """WordNumber_unsigned_right_shift(WordNumber_ptr v, int numberOfBits) -> WordNumber_ptr"""
    return _utils.WordNumber_unsigned_right_shift(v, numberOfBits)

def WordNumber_signed_right_shift(v: 'WordNumber_ptr', numberOfBits: 'int') -> "WordNumber_ptr":
    """WordNumber_signed_right_shift(WordNumber_ptr v, int numberOfBits) -> WordNumber_ptr"""
    return _utils.WordNumber_signed_right_shift(v, numberOfBits)

def WordNumber_left_shift(v: 'WordNumber_ptr', numberOfBits: 'int') -> "WordNumber_ptr":
    """WordNumber_left_shift(WordNumber_ptr v, int numberOfBits) -> WordNumber_ptr"""
    return _utils.WordNumber_left_shift(v, numberOfBits)

def WordNumber_right_rotate(v: 'WordNumber_ptr', numberOfBits: 'int') -> "WordNumber_ptr":
    """WordNumber_right_rotate(WordNumber_ptr v, int numberOfBits) -> WordNumber_ptr"""
    return _utils.WordNumber_right_rotate(v, numberOfBits)

def WordNumber_left_rotate(v: 'WordNumber_ptr', numberOfBits: 'int') -> "WordNumber_ptr":
    """WordNumber_left_rotate(WordNumber_ptr v, int numberOfBits) -> WordNumber_ptr"""
    return _utils.WordNumber_left_rotate(v, numberOfBits)

def WordNumber_unsigned_extend(v: 'WordNumber_ptr', numberOfTimes: 'int') -> "WordNumber_ptr":
    """WordNumber_unsigned_extend(WordNumber_ptr v, int numberOfTimes) -> WordNumber_ptr"""
    return _utils.WordNumber_unsigned_extend(v, numberOfTimes)

def WordNumber_signed_extend(v: 'WordNumber_ptr', numberOfTimes: 'int') -> "WordNumber_ptr":
    """WordNumber_signed_extend(WordNumber_ptr v, int numberOfTimes) -> WordNumber_ptr"""
    return _utils.WordNumber_signed_extend(v, numberOfTimes)

def array_alloc_strings(number: 'int') -> "array_t *":
    """array_alloc_strings(int number) -> array_t"""
    return _utils.array_alloc_strings(number)

def array_insert_strings(array: 'array_t', i: 'int', datum: 'char const *') -> "void":
    """array_insert_strings(array_t array, int i, char const * datum)"""
    return _utils.array_insert_strings(array, i, datum)

def array_fetch_strings(array: 'array_t', i: 'int') -> "char const *":
    """array_fetch_strings(array_t array, int i) -> char const *"""
    return _utils.array_fetch_strings(array, i)

def stdio_fopen(fname: 'char const *', mode: 'char const *') -> "FILE *":
    """stdio_fopen(char const * fname, char const * mode) -> FILE *"""
    return _utils.stdio_fopen(fname, mode)

def stdio_stdin() -> "FILE *":
    """stdio_stdin() -> FILE *"""
    return _utils.stdio_stdin()

def stdio_stdout() -> "FILE *":
    """stdio_stdout() -> FILE *"""
    return _utils.stdio_stdout()

def stdio_stderr() -> "FILE *":
    """stdio_stderr() -> FILE *"""
    return _utils.stdio_stderr()

def stdio_fclose(f: 'FILE *') -> "int":
    """stdio_fclose(FILE * f) -> int"""
    return _utils.stdio_fclose(f)

def void_star_to_int(p: 'void *') -> "int":
    """void_star_to_int(void * p) -> int"""
    return _utils.void_star_to_int(p)

def int_to_void_star(i: 'int') -> "void *":
    """int_to_void_star(int i) -> void *"""
    return _utils.int_to_void_star(i)

def void_star_to_int_star(p: 'void *') -> "int *":
    """void_star_to_int_star(void * p) -> int *"""
    return _utils.void_star_to_int_star(p)

def slist_to_void_star(l: 'Slist_ptr') -> "void *":
    """slist_to_void_star(Slist_ptr l) -> void *"""
    return _utils.slist_to_void_star(l)

def void_star_to_slist(p: 'void *') -> "Slist_ptr":
    """void_star_to_slist(void * p) -> Slist_ptr"""
    return _utils.void_star_to_slist(p)

def str_to_void_star(text: 'char *') -> "void *":
    """str_to_void_star(char * text) -> void *"""
    return _utils.str_to_void_star(text)

def void_star_to_str(ptr: 'void *') -> "char *":
    """void_star_to_str(void * ptr) -> char *"""
    return _utils.void_star_to_str(ptr)
# This file is compatible with both classic and new-style classes.


