# 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, '_symb_table')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_symb_table')
    _symb_table = 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('_symb_table', [dirname(__file__)])
        except ImportError:
            import _symb_table
            return _symb_table
        if fp is not None:
            try:
                _mod = imp.load_module('_symb_table', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _symb_table = swig_import_helper()
    del swig_import_helper
else:
    import _symb_table
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 = _symb_table.PRIuPTR
PRIdPTR = _symb_table.PRIdPTR
LLU = _symb_table.LLU
LLO = _symb_table.LLO
LLX = _symb_table.LLX
false = _symb_table.false
true = _symb_table.true
OUTCOME_GENERIC_ERROR = _symb_table.OUTCOME_GENERIC_ERROR
OUTCOME_PARSER_ERROR = _symb_table.OUTCOME_PARSER_ERROR
OUTCOME_SYNTAX_ERROR = _symb_table.OUTCOME_SYNTAX_ERROR
OUTCOME_FILE_ERROR = _symb_table.OUTCOME_FILE_ERROR
OUTCOME_SUCCESS_REQUIRED_HELP = _symb_table.OUTCOME_SUCCESS_REQUIRED_HELP
OUTCOME_SUCCESS = _symb_table.OUTCOME_SUCCESS

def NFunction_create_uninterpreted(num_args: 'int', args: 'SymbType_ptr *', ret: 'SymbType_ptr') -> "NFunction_ptr":
    """NFunction_create_uninterpreted(int num_args, SymbType_ptr * args, SymbType_ptr ret) -> NFunction_ptr"""
    return _symb_table.NFunction_create_uninterpreted(num_args, args, ret)

def NFunction_create_interpreted(num_args: 'int', args: 'SymbType_ptr *', ret: 'SymbType_ptr', body: 'void *') -> "NFunction_ptr":
    """NFunction_create_interpreted(int num_args, SymbType_ptr * args, SymbType_ptr ret, void * body) -> NFunction_ptr"""
    return _symb_table.NFunction_create_interpreted(num_args, args, ret, body)

def NFunction_destroy(arg1: 'NFunction_ptr') -> "void":
    """NFunction_destroy(NFunction_ptr arg1)"""
    return _symb_table.NFunction_destroy(arg1)

def NFunction_get_args_number(arg1: 'NFunction_ptr') -> "int":
    """NFunction_get_args_number(NFunction_ptr arg1) -> int"""
    return _symb_table.NFunction_get_args_number(arg1)

def NFunction_get_args(arg1: 'NFunction_ptr') -> "NodeList_ptr":
    """NFunction_get_args(NFunction_ptr arg1) -> NodeList_ptr"""
    return _symb_table.NFunction_get_args(arg1)

def NFunction_get_return_type(arg1: 'NFunction_ptr') -> "SymbType_ptr":
    """NFunction_get_return_type(NFunction_ptr arg1) -> SymbType_ptr"""
    return _symb_table.NFunction_get_return_type(arg1)

def NFunction_get_main_type(arg1: 'NFunction_ptr') -> "SymbType_ptr":
    """NFunction_get_main_type(NFunction_ptr arg1) -> SymbType_ptr"""
    return _symb_table.NFunction_get_main_type(arg1)

def NFunction_is_uninterpreted(arg1: 'NFunction_ptr') -> "boolean":
    """NFunction_is_uninterpreted(NFunction_ptr arg1) -> boolean"""
    return _symb_table.NFunction_is_uninterpreted(arg1)

def NFunction_get_body(arg1: 'NFunction_ptr') -> "void *":
    """NFunction_get_body(NFunction_ptr arg1) -> void *"""
    return _symb_table.NFunction_get_body(arg1)

def ResolveSymbol_create() -> "ResolveSymbol_ptr":
    """ResolveSymbol_create() -> ResolveSymbol_ptr"""
    return _symb_table.ResolveSymbol_create()

def ResolveSymbol_destroy(arg1: 'ResolveSymbol_ptr') -> "void":
    """ResolveSymbol_destroy(ResolveSymbol_ptr arg1)"""
    return _symb_table.ResolveSymbol_destroy(arg1)

def ResolveSymbol_is_undefined(arg1: 'ResolveSymbol_ptr') -> "boolean":
    """ResolveSymbol_is_undefined(ResolveSymbol_ptr arg1) -> boolean"""
    return _symb_table.ResolveSymbol_is_undefined(arg1)

def ResolveSymbol_is_defined(arg1: 'ResolveSymbol_ptr') -> "boolean":
    """ResolveSymbol_is_defined(ResolveSymbol_ptr arg1) -> boolean"""
    return _symb_table.ResolveSymbol_is_defined(arg1)

def ResolveSymbol_is_ambiguous(arg1: 'ResolveSymbol_ptr') -> "boolean":
    """ResolveSymbol_is_ambiguous(ResolveSymbol_ptr arg1) -> boolean"""
    return _symb_table.ResolveSymbol_is_ambiguous(arg1)

def ResolveSymbol_is_var(arg1: 'ResolveSymbol_ptr') -> "boolean":
    """ResolveSymbol_is_var(ResolveSymbol_ptr arg1) -> boolean"""
    return _symb_table.ResolveSymbol_is_var(arg1)

def ResolveSymbol_is_define(arg1: 'ResolveSymbol_ptr') -> "boolean":
    """ResolveSymbol_is_define(ResolveSymbol_ptr arg1) -> boolean"""
    return _symb_table.ResolveSymbol_is_define(arg1)

def ResolveSymbol_is_function(arg1: 'ResolveSymbol_ptr') -> "boolean":
    """ResolveSymbol_is_function(ResolveSymbol_ptr arg1) -> boolean"""
    return _symb_table.ResolveSymbol_is_function(arg1)

def ResolveSymbol_is_constant(arg1: 'ResolveSymbol_ptr') -> "boolean":
    """ResolveSymbol_is_constant(ResolveSymbol_ptr arg1) -> boolean"""
    return _symb_table.ResolveSymbol_is_constant(arg1)

def ResolveSymbol_is_parameter(arg1: 'ResolveSymbol_ptr') -> "boolean":
    """ResolveSymbol_is_parameter(ResolveSymbol_ptr arg1) -> boolean"""
    return _symb_table.ResolveSymbol_is_parameter(arg1)

def ResolveSymbol_is_array(arg1: 'ResolveSymbol_ptr') -> "boolean":
    """ResolveSymbol_is_array(ResolveSymbol_ptr arg1) -> boolean"""
    return _symb_table.ResolveSymbol_is_array(arg1)

def ResolveSymbol_is_array_def(arg1: 'ResolveSymbol_ptr') -> "boolean":
    """ResolveSymbol_is_array_def(ResolveSymbol_ptr arg1) -> boolean"""
    return _symb_table.ResolveSymbol_is_array_def(arg1)

def ResolveSymbol_is_error(arg1: 'ResolveSymbol_ptr') -> "boolean":
    """ResolveSymbol_is_error(ResolveSymbol_ptr arg1) -> boolean"""
    return _symb_table.ResolveSymbol_is_error(arg1)

def ResolveSymbol_get_error_message(arg1: 'ResolveSymbol_ptr') -> "char *":
    """ResolveSymbol_get_error_message(ResolveSymbol_ptr arg1) -> char *"""
    return _symb_table.ResolveSymbol_get_error_message(arg1)

def ResolveSymbol_print_error_message(arg1: 'ResolveSymbol_ptr', stream: 'FILE *') -> "void":
    """ResolveSymbol_print_error_message(ResolveSymbol_ptr arg1, FILE * stream)"""
    return _symb_table.ResolveSymbol_print_error_message(arg1, stream)

def ResolveSymbol_throw_error(arg1: 'ResolveSymbol_ptr') -> "void":
    """ResolveSymbol_throw_error(ResolveSymbol_ptr arg1)"""
    return _symb_table.ResolveSymbol_throw_error(arg1)

def ResolveSymbol_get_resolved_name(arg1: 'ResolveSymbol_ptr') -> "node_ptr":
    """ResolveSymbol_get_resolved_name(ResolveSymbol_ptr arg1) -> node_ptr"""
    return _symb_table.ResolveSymbol_get_resolved_name(arg1)

def ResolveSymbol_resolve(arg1: 'ResolveSymbol_ptr', st: 'struct SymbTable_TAG *', name: 'node_ptr', context: 'node_ptr') -> "node_ptr":
    """ResolveSymbol_resolve(ResolveSymbol_ptr arg1, struct SymbTable_TAG * st, node_ptr name, node_ptr context) -> node_ptr"""
    return _symb_table.ResolveSymbol_resolve(arg1, st, name, context)

def SymbTablePkg_no_type() -> "SymbType_ptr":
    """SymbTablePkg_no_type() -> SymbType_ptr"""
    return _symb_table.SymbTablePkg_no_type()

def SymbTablePkg_statement_type() -> "SymbType_ptr":
    """SymbTablePkg_statement_type() -> SymbType_ptr"""
    return _symb_table.SymbTablePkg_statement_type()

def SymbTablePkg_boolean_type() -> "SymbType_ptr":
    """SymbTablePkg_boolean_type() -> SymbType_ptr"""
    return _symb_table.SymbTablePkg_boolean_type()

def SymbTablePkg_pure_symbolic_enum_type() -> "SymbType_ptr":
    """SymbTablePkg_pure_symbolic_enum_type() -> SymbType_ptr"""
    return _symb_table.SymbTablePkg_pure_symbolic_enum_type()

def SymbTablePkg_int_symbolic_enum_type() -> "SymbType_ptr":
    """SymbTablePkg_int_symbolic_enum_type() -> SymbType_ptr"""
    return _symb_table.SymbTablePkg_int_symbolic_enum_type()

def SymbTablePkg_pure_int_enum_type() -> "SymbType_ptr":
    """SymbTablePkg_pure_int_enum_type() -> SymbType_ptr"""
    return _symb_table.SymbTablePkg_pure_int_enum_type()

def SymbTablePkg_integer_type() -> "SymbType_ptr":
    """SymbTablePkg_integer_type() -> SymbType_ptr"""
    return _symb_table.SymbTablePkg_integer_type()

def SymbTablePkg_real_type() -> "SymbType_ptr":
    """SymbTablePkg_real_type() -> SymbType_ptr"""
    return _symb_table.SymbTablePkg_real_type()

def SymbTablePkg_unsigned_word_type(width: 'int') -> "SymbType_ptr":
    """SymbTablePkg_unsigned_word_type(int width) -> SymbType_ptr"""
    return _symb_table.SymbTablePkg_unsigned_word_type(width)

def SymbTablePkg_signed_word_type(width: 'int') -> "SymbType_ptr":
    """SymbTablePkg_signed_word_type(int width) -> SymbType_ptr"""
    return _symb_table.SymbTablePkg_signed_word_type(width)

def SymbTablePkg_wordarray_type(awidth: 'int', vwidth: 'int') -> "SymbType_ptr":
    """SymbTablePkg_wordarray_type(int awidth, int vwidth) -> SymbType_ptr"""
    return _symb_table.SymbTablePkg_wordarray_type(awidth, vwidth)

def SymbTablePkg_array_type(subtype: 'SymbType_ptr', lower_bound: 'int', upper_bound: 'int') -> "SymbType_ptr":
    """SymbTablePkg_array_type(SymbType_ptr subtype, int lower_bound, int upper_bound) -> SymbType_ptr"""
    return _symb_table.SymbTablePkg_array_type(subtype, lower_bound, upper_bound)

def SymbTablePkg_string_type() -> "SymbType_ptr":
    """SymbTablePkg_string_type() -> SymbType_ptr"""
    return _symb_table.SymbTablePkg_string_type()

def SymbTablePkg_boolean_set_type() -> "SymbType_ptr":
    """SymbTablePkg_boolean_set_type() -> SymbType_ptr"""
    return _symb_table.SymbTablePkg_boolean_set_type()

def SymbTablePkg_integer_set_type() -> "SymbType_ptr":
    """SymbTablePkg_integer_set_type() -> SymbType_ptr"""
    return _symb_table.SymbTablePkg_integer_set_type()

def SymbTablePkg_symbolic_set_type() -> "SymbType_ptr":
    """SymbTablePkg_symbolic_set_type() -> SymbType_ptr"""
    return _symb_table.SymbTablePkg_symbolic_set_type()

def SymbTablePkg_integer_symbolic_set_type() -> "SymbType_ptr":
    """SymbTablePkg_integer_symbolic_set_type() -> SymbType_ptr"""
    return _symb_table.SymbTablePkg_integer_symbolic_set_type()

def SymbTablePkg_error_type() -> "SymbType_ptr":
    """SymbTablePkg_error_type() -> SymbType_ptr"""
    return _symb_table.SymbTablePkg_error_type()

def SymbCache_get_var_type(arg1: 'SymbCache_ptr const', name: 'node_ptr const') -> "SymbType_ptr":
    """SymbCache_get_var_type(SymbCache_ptr const arg1, node_ptr const name) -> SymbType_ptr"""
    return _symb_table.SymbCache_get_var_type(arg1, name)

def SymbCache_get_define_body(arg1: 'SymbCache_ptr const', name: 'node_ptr const') -> "node_ptr":
    """SymbCache_get_define_body(SymbCache_ptr const arg1, node_ptr const name) -> node_ptr"""
    return _symb_table.SymbCache_get_define_body(arg1, name)

def SymbCache_get_function(arg1: 'SymbCache_ptr const', name: 'node_ptr const') -> "NFunction_ptr":
    """SymbCache_get_function(SymbCache_ptr const arg1, node_ptr const name) -> NFunction_ptr"""
    return _symb_table.SymbCache_get_function(arg1, name)

def SymbCache_get_actual_parameter(arg1: 'SymbCache_ptr const', name: 'node_ptr const') -> "node_ptr":
    """SymbCache_get_actual_parameter(SymbCache_ptr const arg1, node_ptr const name) -> node_ptr"""
    return _symb_table.SymbCache_get_actual_parameter(arg1, name)

def SymbCache_get_array_define_body(arg1: 'SymbCache_ptr const', name: 'node_ptr const') -> "node_ptr":
    """SymbCache_get_array_define_body(SymbCache_ptr const arg1, node_ptr const name) -> node_ptr"""
    return _symb_table.SymbCache_get_array_define_body(arg1, name)

def SymbCache_get_variable_array_type(arg1: 'SymbCache_ptr const', name: 'node_ptr const') -> "SymbType_ptr":
    """SymbCache_get_variable_array_type(SymbCache_ptr const arg1, node_ptr const name) -> SymbType_ptr"""
    return _symb_table.SymbCache_get_variable_array_type(arg1, name)

def SymbCache_get_define_flatten_body(arg1: 'SymbCache_ptr const', name: 'node_ptr const') -> "node_ptr":
    """SymbCache_get_define_flatten_body(SymbCache_ptr const arg1, node_ptr const name) -> node_ptr"""
    return _symb_table.SymbCache_get_define_flatten_body(arg1, name)

def SymbCache_get_flatten_actual_parameter(arg1: 'SymbCache_ptr const', name: 'node_ptr const') -> "node_ptr":
    """SymbCache_get_flatten_actual_parameter(SymbCache_ptr const arg1, node_ptr const name) -> node_ptr"""
    return _symb_table.SymbCache_get_flatten_actual_parameter(arg1, name)

def SymbCache_get_define_context(arg1: 'SymbCache_ptr const', name: 'node_ptr const') -> "node_ptr":
    """SymbCache_get_define_context(SymbCache_ptr const arg1, node_ptr const name) -> node_ptr"""
    return _symb_table.SymbCache_get_define_context(arg1, name)

def SymbCache_get_function_context(arg1: 'SymbCache_ptr const', name: 'node_ptr const') -> "node_ptr":
    """SymbCache_get_function_context(SymbCache_ptr const arg1, node_ptr const name) -> node_ptr"""
    return _symb_table.SymbCache_get_function_context(arg1, name)

def SymbCache_get_actual_parameter_context(arg1: 'SymbCache_ptr const', name: 'node_ptr const') -> "node_ptr":
    """SymbCache_get_actual_parameter_context(SymbCache_ptr const arg1, node_ptr const name) -> node_ptr"""
    return _symb_table.SymbCache_get_actual_parameter_context(arg1, name)

def SymbCache_get_array_define_context(arg1: 'SymbCache_ptr const', name: 'node_ptr const') -> "node_ptr":
    """SymbCache_get_array_define_context(SymbCache_ptr const arg1, node_ptr const name) -> node_ptr"""
    return _symb_table.SymbCache_get_array_define_context(arg1, name)

def SymbCache_is_symbol_state_var(arg1: 'SymbCache_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbCache_is_symbol_state_var(SymbCache_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbCache_is_symbol_state_var(arg1, name)

def SymbCache_is_symbol_frozen_var(arg1: 'SymbCache_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbCache_is_symbol_frozen_var(SymbCache_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbCache_is_symbol_frozen_var(arg1, name)

def SymbCache_is_symbol_state_frozen_var(arg1: 'SymbCache_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbCache_is_symbol_state_frozen_var(SymbCache_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbCache_is_symbol_state_frozen_var(arg1, name)

def SymbCache_is_symbol_input_var(arg1: 'SymbCache_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbCache_is_symbol_input_var(SymbCache_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbCache_is_symbol_input_var(arg1, name)

def SymbCache_is_symbol_var(arg1: 'SymbCache_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbCache_is_symbol_var(SymbCache_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbCache_is_symbol_var(arg1, name)

def SymbCache_is_symbol_declared(arg1: 'SymbCache_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbCache_is_symbol_declared(SymbCache_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbCache_is_symbol_declared(arg1, name)

def SymbCache_is_symbol_define(arg1: 'SymbCache_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbCache_is_symbol_define(SymbCache_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbCache_is_symbol_define(arg1, name)

def SymbCache_is_symbol_function(arg1: 'SymbCache_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbCache_is_symbol_function(SymbCache_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbCache_is_symbol_function(arg1, name)

def SymbCache_is_symbol_parameter(arg1: 'SymbCache_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbCache_is_symbol_parameter(SymbCache_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbCache_is_symbol_parameter(arg1, name)

def SymbCache_is_symbol_array_define(arg1: 'SymbCache_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbCache_is_symbol_array_define(SymbCache_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbCache_is_symbol_array_define(arg1, name)

def SymbCache_is_symbol_variable_array(arg1: 'SymbCache_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbCache_is_symbol_variable_array(SymbCache_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbCache_is_symbol_variable_array(arg1, name)

def SymbCache_is_symbol_constant(arg1: 'SymbCache_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbCache_is_symbol_constant(SymbCache_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbCache_is_symbol_constant(arg1, name)

def SymbCache_list_contains_input_var(arg1: 'SymbCache_ptr const', var_list: 'NodeList_ptr const') -> "boolean":
    """SymbCache_list_contains_input_var(SymbCache_ptr const arg1, NodeList_ptr const var_list) -> boolean"""
    return _symb_table.SymbCache_list_contains_input_var(arg1, var_list)

def SymbCache_list_contains_state_frozen_var(arg1: 'SymbCache_ptr const', var_list: 'NodeList_ptr const') -> "boolean":
    """SymbCache_list_contains_state_frozen_var(SymbCache_ptr const arg1, NodeList_ptr const var_list) -> boolean"""
    return _symb_table.SymbCache_list_contains_state_frozen_var(arg1, var_list)

def SymbCache_list_contains_undef_var(arg1: 'SymbCache_ptr const', var_list: 'NodeList_ptr const') -> "boolean":
    """SymbCache_list_contains_undef_var(SymbCache_ptr const arg1, NodeList_ptr const var_list) -> boolean"""
    return _symb_table.SymbCache_list_contains_undef_var(arg1, var_list)
SYMB_LAYER_POS_DEFAULT = _symb_table.SYMB_LAYER_POS_DEFAULT
SYMB_LAYER_POS_FORCE_TOP = _symb_table.SYMB_LAYER_POS_FORCE_TOP
SYMB_LAYER_POS_TOP = _symb_table.SYMB_LAYER_POS_TOP
SYMB_LAYER_POS_BOTTOM = _symb_table.SYMB_LAYER_POS_BOTTOM
SYMB_LAYER_POS_FORCE_BOTTOM = _symb_table.SYMB_LAYER_POS_FORCE_BOTTOM
class SymbLayerIter(_object):
    """Proxy of C SymbLayerIter_TAG struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SymbLayerIter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SymbLayerIter, name)
    __repr__ = _swig_repr
    __swig_setmethods__["index"] = _symb_table.SymbLayerIter_index_set
    __swig_getmethods__["index"] = _symb_table.SymbLayerIter_index_get
    if _newclass:
        index = _swig_property(_symb_table.SymbLayerIter_index_get, _symb_table.SymbLayerIter_index_set)
    __swig_setmethods__["mask"] = _symb_table.SymbLayerIter_mask_set
    __swig_getmethods__["mask"] = _symb_table.SymbLayerIter_mask_get
    if _newclass:
        mask = _swig_property(_symb_table.SymbLayerIter_mask_get, _symb_table.SymbLayerIter_mask_set)
    __swig_setmethods__["filter"] = _symb_table.SymbLayerIter_filter_set
    __swig_getmethods__["filter"] = _symb_table.SymbLayerIter_filter_get
    if _newclass:
        filter = _swig_property(_symb_table.SymbLayerIter_filter_get, _symb_table.SymbLayerIter_filter_set)
    __swig_setmethods__["arg"] = _symb_table.SymbLayerIter_arg_set
    __swig_getmethods__["arg"] = _symb_table.SymbLayerIter_arg_get
    if _newclass:
        arg = _swig_property(_symb_table.SymbLayerIter_arg_get, _symb_table.SymbLayerIter_arg_set)

    def __init__(self):
        """__init__(SymbLayerIter_TAG self) -> SymbLayerIter"""
        this = _symb_table.new_SymbLayerIter()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _symb_table.delete_SymbLayerIter
    __del__ = lambda self: None
SymbLayerIter_swigregister = _symb_table.SymbLayerIter_swigregister
SymbLayerIter_swigregister(SymbLayerIter)


def SymbLayer_gen_iter(arg1: 'SymbLayer_ptr const', iter: 'SymbLayerIter', mask: 'unsigned int') -> "void":
    """SymbLayer_gen_iter(SymbLayer_ptr const arg1, SymbLayerIter iter, unsigned int mask)"""
    return _symb_table.SymbLayer_gen_iter(arg1, iter, mask)

def SymbLayer_iter_next(arg1: 'SymbLayer_ptr const', iter: 'SymbLayerIter') -> "void":
    """SymbLayer_iter_next(SymbLayer_ptr const arg1, SymbLayerIter iter)"""
    return _symb_table.SymbLayer_iter_next(arg1, iter)

def SymbLayer_iter_is_end(arg1: 'SymbLayer_ptr const', iter: 'SymbLayerIter') -> "boolean":
    """SymbLayer_iter_is_end(SymbLayer_ptr const arg1, SymbLayerIter iter) -> boolean"""
    return _symb_table.SymbLayer_iter_is_end(arg1, iter)

def SymbLayer_iter_get_symbol(arg1: 'SymbLayer_ptr const', iter: 'SymbLayerIter') -> "node_ptr":
    """SymbLayer_iter_get_symbol(SymbLayer_ptr const arg1, SymbLayerIter iter) -> node_ptr"""
    return _symb_table.SymbLayer_iter_get_symbol(arg1, iter)

def SymbLayer_iter_set_filter(layer: 'SymbLayer_ptr const', iter: 'SymbLayerIter', fun: 'SymbLayerIterFilterFun', arg: 'void *') -> "void":
    """SymbLayer_iter_set_filter(SymbLayer_ptr const layer, SymbLayerIter iter, SymbLayerIterFilterFun fun, void * arg)"""
    return _symb_table.SymbLayer_iter_set_filter(layer, iter, fun, arg)

def SymbLayer_iter_filter_bool_vars(arg1: 'SymbLayer_ptr const', sym: 'node_ptr const', arg: 'void *') -> "boolean":
    """SymbLayer_iter_filter_bool_vars(SymbLayer_ptr const arg1, node_ptr const sym, void * arg) -> boolean"""
    return _symb_table.SymbLayer_iter_filter_bool_vars(arg1, sym, arg)

def SymbLayer_iter_to_set(arg1: 'SymbLayer_ptr const', iter: 'SymbLayerIter') -> "Set_t":
    """SymbLayer_iter_to_set(SymbLayer_ptr const arg1, SymbLayerIter iter) -> Set_t"""
    return _symb_table.SymbLayer_iter_to_set(arg1, iter)

def SymbLayer_iter_to_list(arg1: 'SymbLayer_ptr const', iter: 'SymbLayerIter') -> "NodeList_ptr":
    """SymbLayer_iter_to_list(SymbLayer_ptr const arg1, SymbLayerIter iter) -> NodeList_ptr"""
    return _symb_table.SymbLayer_iter_to_list(arg1, iter)

def SymbLayer_iter_count(arg1: 'SymbLayer_ptr const', iter: 'SymbLayerIter') -> "unsigned int":
    """SymbLayer_iter_count(SymbLayer_ptr const arg1, SymbLayerIter iter) -> unsigned int"""
    return _symb_table.SymbLayer_iter_count(arg1, iter)

def SymbLayer_get_name(arg1: 'SymbLayer_ptr const') -> "char const *":
    """SymbLayer_get_name(SymbLayer_ptr const arg1) -> char const *"""
    return _symb_table.SymbLayer_get_name(arg1)

def SymbLayer_can_declare_constant(arg1: 'SymbLayer_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbLayer_can_declare_constant(SymbLayer_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbLayer_can_declare_constant(arg1, name)

def SymbLayer_declare_constant(arg1: 'SymbLayer_ptr', name: 'node_ptr') -> "void":
    """SymbLayer_declare_constant(SymbLayer_ptr arg1, node_ptr name)"""
    return _symb_table.SymbLayer_declare_constant(arg1, name)

def SymbLayer_can_declare_var(arg1: 'SymbLayer_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbLayer_can_declare_var(SymbLayer_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbLayer_can_declare_var(arg1, name)

def SymbLayer_declare_input_var(arg1: 'SymbLayer_ptr', var: 'node_ptr', type: 'SymbType_ptr') -> "void":
    """SymbLayer_declare_input_var(SymbLayer_ptr arg1, node_ptr var, SymbType_ptr type)"""
    return _symb_table.SymbLayer_declare_input_var(arg1, var, type)

def SymbLayer_declare_state_var(arg1: 'SymbLayer_ptr', var: 'node_ptr', type: 'SymbType_ptr') -> "void":
    """SymbLayer_declare_state_var(SymbLayer_ptr arg1, node_ptr var, SymbType_ptr type)"""
    return _symb_table.SymbLayer_declare_state_var(arg1, var, type)

def SymbLayer_declare_frozen_var(arg1: 'SymbLayer_ptr', var: 'node_ptr', type: 'SymbType_ptr') -> "void":
    """SymbLayer_declare_frozen_var(SymbLayer_ptr arg1, node_ptr var, SymbType_ptr type)"""
    return _symb_table.SymbLayer_declare_frozen_var(arg1, var, type)

def SymbLayer_redeclare_state_as_frozen_var(arg1: 'SymbLayer_ptr', var: 'node_ptr') -> "void":
    """SymbLayer_redeclare_state_as_frozen_var(SymbLayer_ptr arg1, node_ptr var)"""
    return _symb_table.SymbLayer_redeclare_state_as_frozen_var(arg1, var)

def SymbLayer_can_declare_define(arg1: 'SymbLayer_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbLayer_can_declare_define(SymbLayer_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbLayer_can_declare_define(arg1, name)

def SymbLayer_can_declare_function(arg1: 'SymbLayer_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbLayer_can_declare_function(SymbLayer_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbLayer_can_declare_function(arg1, name)

def SymbLayer_can_declare_parameter(arg1: 'SymbLayer_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbLayer_can_declare_parameter(SymbLayer_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbLayer_can_declare_parameter(arg1, name)

def SymbLayer_can_declare_array_define(arg1: 'SymbLayer_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbLayer_can_declare_array_define(SymbLayer_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbLayer_can_declare_array_define(arg1, name)

def SymbLayer_can_declare_variable_array(arg1: 'SymbLayer_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbLayer_can_declare_variable_array(SymbLayer_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbLayer_can_declare_variable_array(arg1, name)

def SymbLayer_declare_define(arg1: 'SymbLayer_ptr', name: 'node_ptr', ctx: 'node_ptr', definition: 'node_ptr') -> "void":
    """SymbLayer_declare_define(SymbLayer_ptr arg1, node_ptr name, node_ptr ctx, node_ptr definition)"""
    return _symb_table.SymbLayer_declare_define(arg1, name, ctx, definition)

def SymbLayer_declare_function(arg1: 'SymbLayer_ptr', name: 'node_ptr', ctx: 'node_ptr', fun: 'NFunction_ptr') -> "void":
    """SymbLayer_declare_function(SymbLayer_ptr arg1, node_ptr name, node_ptr ctx, NFunction_ptr fun)"""
    return _symb_table.SymbLayer_declare_function(arg1, name, ctx, fun)

def SymbLayer_declare_parameter(arg1: 'SymbLayer_ptr', formal: 'node_ptr', ctx: 'node_ptr', actual: 'node_ptr') -> "void":
    """SymbLayer_declare_parameter(SymbLayer_ptr arg1, node_ptr formal, node_ptr ctx, node_ptr actual)"""
    return _symb_table.SymbLayer_declare_parameter(arg1, formal, ctx, actual)

def SymbLayer_declare_array_define(arg1: 'SymbLayer_ptr', name: 'node_ptr', ctx: 'node_ptr', definition: 'node_ptr') -> "void":
    """SymbLayer_declare_array_define(SymbLayer_ptr arg1, node_ptr name, node_ptr ctx, node_ptr definition)"""
    return _symb_table.SymbLayer_declare_array_define(arg1, name, ctx, definition)

def SymbLayer_declare_variable_array(arg1: 'SymbLayer_ptr', var: 'node_ptr', type: 'SymbType_ptr') -> "void":
    """SymbLayer_declare_variable_array(SymbLayer_ptr arg1, node_ptr var, SymbType_ptr type)"""
    return _symb_table.SymbLayer_declare_variable_array(arg1, var, type)

def SymbLayer_remove_var(arg1: 'SymbLayer_ptr', name: 'node_ptr') -> "void":
    """SymbLayer_remove_var(SymbLayer_ptr arg1, node_ptr name)"""
    return _symb_table.SymbLayer_remove_var(arg1, name)

def SymbLayer_remove_define(arg1: 'SymbLayer_ptr', name: 'node_ptr') -> "void":
    """SymbLayer_remove_define(SymbLayer_ptr arg1, node_ptr name)"""
    return _symb_table.SymbLayer_remove_define(arg1, name)

def SymbLayer_remove_function(arg1: 'SymbLayer_ptr', name: 'node_ptr') -> "void":
    """SymbLayer_remove_function(SymbLayer_ptr arg1, node_ptr name)"""
    return _symb_table.SymbLayer_remove_function(arg1, name)

def SymbLayer_get_symbols_num(arg1: 'SymbLayer_ptr const') -> "int":
    """SymbLayer_get_symbols_num(SymbLayer_ptr const arg1) -> int"""
    return _symb_table.SymbLayer_get_symbols_num(arg1)

def SymbLayer_get_constants_num(arg1: 'SymbLayer_ptr const') -> "int":
    """SymbLayer_get_constants_num(SymbLayer_ptr const arg1) -> int"""
    return _symb_table.SymbLayer_get_constants_num(arg1)

def SymbLayer_get_state_vars_num(arg1: 'SymbLayer_ptr const') -> "int":
    """SymbLayer_get_state_vars_num(SymbLayer_ptr const arg1) -> int"""
    return _symb_table.SymbLayer_get_state_vars_num(arg1)

def SymbLayer_get_bool_state_vars_num(arg1: 'SymbLayer_ptr const') -> "int":
    """SymbLayer_get_bool_state_vars_num(SymbLayer_ptr const arg1) -> int"""
    return _symb_table.SymbLayer_get_bool_state_vars_num(arg1)

def SymbLayer_get_frozen_vars_num(arg1: 'SymbLayer_ptr const') -> "int":
    """SymbLayer_get_frozen_vars_num(SymbLayer_ptr const arg1) -> int"""
    return _symb_table.SymbLayer_get_frozen_vars_num(arg1)

def SymbLayer_get_bool_frozen_vars_num(arg1: 'SymbLayer_ptr const') -> "int":
    """SymbLayer_get_bool_frozen_vars_num(SymbLayer_ptr const arg1) -> int"""
    return _symb_table.SymbLayer_get_bool_frozen_vars_num(arg1)

def SymbLayer_get_input_vars_num(arg1: 'SymbLayer_ptr const') -> "int":
    """SymbLayer_get_input_vars_num(SymbLayer_ptr const arg1) -> int"""
    return _symb_table.SymbLayer_get_input_vars_num(arg1)

def SymbLayer_get_vars_num(arg1: 'SymbLayer_ptr const') -> "int":
    """SymbLayer_get_vars_num(SymbLayer_ptr const arg1) -> int"""
    return _symb_table.SymbLayer_get_vars_num(arg1)

def SymbLayer_get_bool_input_vars_num(arg1: 'SymbLayer_ptr const') -> "int":
    """SymbLayer_get_bool_input_vars_num(SymbLayer_ptr const arg1) -> int"""
    return _symb_table.SymbLayer_get_bool_input_vars_num(arg1)

def SymbLayer_get_defines_num(arg1: 'SymbLayer_ptr const') -> "int":
    """SymbLayer_get_defines_num(SymbLayer_ptr const arg1) -> int"""
    return _symb_table.SymbLayer_get_defines_num(arg1)

def SymbLayer_get_functions_num(arg1: 'SymbLayer_ptr const') -> "int":
    """SymbLayer_get_functions_num(SymbLayer_ptr const arg1) -> int"""
    return _symb_table.SymbLayer_get_functions_num(arg1)

def SymbLayer_get_parameters_num(arg1: 'SymbLayer_ptr const') -> "int":
    """SymbLayer_get_parameters_num(SymbLayer_ptr const arg1) -> int"""
    return _symb_table.SymbLayer_get_parameters_num(arg1)

def SymbLayer_get_array_defines_num(arg1: 'SymbLayer_ptr const') -> "int":
    """SymbLayer_get_array_defines_num(SymbLayer_ptr const arg1) -> int"""
    return _symb_table.SymbLayer_get_array_defines_num(arg1)

def SymbLayer_get_variable_arrays_num(arg1: 'SymbLayer_ptr const') -> "int":
    """SymbLayer_get_variable_arrays_num(SymbLayer_ptr const arg1) -> int"""
    return _symb_table.SymbLayer_get_variable_arrays_num(arg1)

def SymbLayer_must_insert_before(arg1: 'SymbLayer_ptr const', other: 'SymbLayer_ptr const') -> "boolean":
    """SymbLayer_must_insert_before(SymbLayer_ptr const arg1, SymbLayer_ptr const other) -> boolean"""
    return _symb_table.SymbLayer_must_insert_before(arg1, other)

def SymbLayer_is_variable_in_layer(arg1: 'SymbLayer_ptr', name: 'node_ptr') -> "boolean":
    """SymbLayer_is_variable_in_layer(SymbLayer_ptr arg1, node_ptr name) -> boolean"""
    return _symb_table.SymbLayer_is_variable_in_layer(arg1, name)

def SymbLayer_is_symbol_in_layer(arg1: 'SymbLayer_ptr', name: 'node_ptr') -> "boolean":
    """SymbLayer_is_symbol_in_layer(SymbLayer_ptr arg1, node_ptr name) -> boolean"""
    return _symb_table.SymbLayer_is_symbol_in_layer(arg1, name)

def SymbLayer_get_insert_policy(arg1: 'SymbLayer_ptr const') -> "LayerInsertPolicy":
    """SymbLayer_get_insert_policy(SymbLayer_ptr const arg1) -> LayerInsertPolicy"""
    return _symb_table.SymbLayer_get_insert_policy(arg1)
VFT_CURRENT = _symb_table.VFT_CURRENT
VFT_NEXT = _symb_table.VFT_NEXT
VFT_STATE = _symb_table.VFT_STATE
VFT_INPUT = _symb_table.VFT_INPUT
VFT_CURR_INPUT = _symb_table.VFT_CURR_INPUT
VFT_FROZEN = _symb_table.VFT_FROZEN
VFT_CURR_FROZEN = _symb_table.VFT_CURR_FROZEN
VFT_ALL = _symb_table.VFT_ALL
VFT_DEFINE = _symb_table.VFT_DEFINE
VFT_ALL_DEFINE = _symb_table.VFT_ALL_DEFINE
SYMBOL_INVALID = _symb_table.SYMBOL_INVALID
SYMBOL_CONSTANT = _symb_table.SYMBOL_CONSTANT
SYMBOL_FROZEN_VAR = _symb_table.SYMBOL_FROZEN_VAR
SYMBOL_STATE_VAR = _symb_table.SYMBOL_STATE_VAR
SYMBOL_INPUT_VAR = _symb_table.SYMBOL_INPUT_VAR
SYMBOL_STATE_DEFINE = _symb_table.SYMBOL_STATE_DEFINE
SYMBOL_INPUT_DEFINE = _symb_table.SYMBOL_INPUT_DEFINE
SYMBOL_STATE_INPUT_DEFINE = _symb_table.SYMBOL_STATE_INPUT_DEFINE
SYMBOL_NEXT_DEFINE = _symb_table.SYMBOL_NEXT_DEFINE
SYMBOL_STATE_NEXT_DEFINE = _symb_table.SYMBOL_STATE_NEXT_DEFINE
SYMBOL_INPUT_NEXT_DEFINE = _symb_table.SYMBOL_INPUT_NEXT_DEFINE
SYMBOL_STATE_INPUT_NEXT_DEFINE = _symb_table.SYMBOL_STATE_INPUT_NEXT_DEFINE
SYMBOL_DEFINE = _symb_table.SYMBOL_DEFINE
SYMBOL_FUNCTION = _symb_table.SYMBOL_FUNCTION
SYMBOL_PARAMETER = _symb_table.SYMBOL_PARAMETER
SYMBOL_ARRAY_DEFINE = _symb_table.SYMBOL_ARRAY_DEFINE
SYMBOL_VARIABLE_ARRAY = _symb_table.SYMBOL_VARIABLE_ARRAY
STT_NONE = _symb_table.STT_NONE
STT_CONSTANT = _symb_table.STT_CONSTANT
STT_STATE_VAR = _symb_table.STT_STATE_VAR
STT_INPUT_VAR = _symb_table.STT_INPUT_VAR
STT_FROZEN_VAR = _symb_table.STT_FROZEN_VAR
STT_VAR = _symb_table.STT_VAR
STT_DEFINE = _symb_table.STT_DEFINE
STT_ARRAY_DEFINE = _symb_table.STT_ARRAY_DEFINE
STT_PARAMETER = _symb_table.STT_PARAMETER
STT_FUNCTION = _symb_table.STT_FUNCTION
STT_VARIABLE_ARRAY = _symb_table.STT_VARIABLE_ARRAY
STT_ALL = _symb_table.STT_ALL
ST_TRIGGER_SYMBOL_ADD = _symb_table.ST_TRIGGER_SYMBOL_ADD
ST_TRIGGER_SYMBOL_REMOVE = _symb_table.ST_TRIGGER_SYMBOL_REMOVE
ST_TRIGGER_SYMBOL_REDECLARE = _symb_table.ST_TRIGGER_SYMBOL_REDECLARE
class SymbTableIter(_object):
    """Proxy of C SymbTableIter_TAG struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SymbTableIter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SymbTableIter, name)
    __repr__ = _swig_repr
    __swig_setmethods__["index"] = _symb_table.SymbTableIter_index_set
    __swig_getmethods__["index"] = _symb_table.SymbTableIter_index_get
    if _newclass:
        index = _swig_property(_symb_table.SymbTableIter_index_get, _symb_table.SymbTableIter_index_set)
    __swig_setmethods__["mask"] = _symb_table.SymbTableIter_mask_set
    __swig_getmethods__["mask"] = _symb_table.SymbTableIter_mask_get
    if _newclass:
        mask = _swig_property(_symb_table.SymbTableIter_mask_get, _symb_table.SymbTableIter_mask_set)
    __swig_setmethods__["filter"] = _symb_table.SymbTableIter_filter_set
    __swig_getmethods__["filter"] = _symb_table.SymbTableIter_filter_get
    if _newclass:
        filter = _swig_property(_symb_table.SymbTableIter_filter_get, _symb_table.SymbTableIter_filter_set)
    __swig_setmethods__["st"] = _symb_table.SymbTableIter_st_set
    __swig_getmethods__["st"] = _symb_table.SymbTableIter_st_get
    if _newclass:
        st = _swig_property(_symb_table.SymbTableIter_st_get, _symb_table.SymbTableIter_st_set)
    __swig_setmethods__["arg"] = _symb_table.SymbTableIter_arg_set
    __swig_getmethods__["arg"] = _symb_table.SymbTableIter_arg_get
    if _newclass:
        arg = _swig_property(_symb_table.SymbTableIter_arg_get, _symb_table.SymbTableIter_arg_set)

    def __init__(self):
        """__init__(SymbTableIter_TAG self) -> SymbTableIter"""
        this = _symb_table.new_SymbTableIter()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _symb_table.delete_SymbTableIter
    __del__ = lambda self: None
SymbTableIter_swigregister = _symb_table.SymbTableIter_swigregister
SymbTableIter_swigregister(SymbTableIter)


def SymbTable_create() -> "SymbTable_ptr":
    """SymbTable_create() -> SymbTable_ptr"""
    return _symb_table.SymbTable_create()

def SymbTable_destroy(arg1: 'SymbTable_ptr') -> "void":
    """SymbTable_destroy(SymbTable_ptr arg1)"""
    return _symb_table.SymbTable_destroy(arg1)

def SymbTable_get_type_checker(arg1: 'SymbTable_ptr const') -> "TypeChecker_ptr":
    """SymbTable_get_type_checker(SymbTable_ptr const arg1) -> TypeChecker_ptr"""
    return _symb_table.SymbTable_get_type_checker(arg1)

def SymbTable_gen_iter(arg1: 'SymbTable_ptr const', iter: 'SymbTableIter', mask: 'unsigned int') -> "void":
    """SymbTable_gen_iter(SymbTable_ptr const arg1, SymbTableIter iter, unsigned int mask)"""
    return _symb_table.SymbTable_gen_iter(arg1, iter, mask)

def SymbTable_iter_next(arg1: 'SymbTable_ptr const', iter: 'SymbTableIter') -> "void":
    """SymbTable_iter_next(SymbTable_ptr const arg1, SymbTableIter iter)"""
    return _symb_table.SymbTable_iter_next(arg1, iter)

def SymbTable_iter_is_end(arg1: 'SymbTable_ptr const', iter: 'SymbTableIter') -> "boolean":
    """SymbTable_iter_is_end(SymbTable_ptr const arg1, SymbTableIter iter) -> boolean"""
    return _symb_table.SymbTable_iter_is_end(arg1, iter)

def SymbTable_iter_get_symbol(arg1: 'SymbTable_ptr const', iter: 'SymbTableIter') -> "node_ptr":
    """SymbTable_iter_get_symbol(SymbTable_ptr const arg1, SymbTableIter iter) -> node_ptr"""
    return _symb_table.SymbTable_iter_get_symbol(arg1, iter)

def SymbTable_iter_set_filter(arg1: 'SymbTable_ptr const', iter: 'SymbTableIter', fun: 'SymbTableIterFilterFun', arg: 'void *') -> "void":
    """SymbTable_iter_set_filter(SymbTable_ptr const arg1, SymbTableIter iter, SymbTableIterFilterFun fun, void * arg)"""
    return _symb_table.SymbTable_iter_set_filter(arg1, iter, fun, arg)

def SymbTable_foreach(arg1: 'SymbTable_ptr const', mask: 'unsigned int', fun: 'SymbTableForeachFun', arg: 'void *') -> "void":
    """SymbTable_foreach(SymbTable_ptr const arg1, unsigned int mask, SymbTableForeachFun fun, void * arg)"""
    return _symb_table.SymbTable_foreach(arg1, mask, fun, arg)

def SymbTable_iter_to_set(arg1: 'SymbTable_ptr const', iter: 'SymbTableIter') -> "Set_t":
    """SymbTable_iter_to_set(SymbTable_ptr const arg1, SymbTableIter iter) -> Set_t"""
    return _symb_table.SymbTable_iter_to_set(arg1, iter)

def SymbTable_iter_to_list(arg1: 'SymbTable_ptr const', iter: 'SymbTableIter') -> "NodeList_ptr":
    """SymbTable_iter_to_list(SymbTable_ptr const arg1, SymbTableIter iter) -> NodeList_ptr"""
    return _symb_table.SymbTable_iter_to_list(arg1, iter)

def SymbTable_iter_count(arg1: 'SymbTable_ptr const', iter: 'SymbTableIter') -> "unsigned int":
    """SymbTable_iter_count(SymbTable_ptr const arg1, SymbTableIter iter) -> unsigned int"""
    return _symb_table.SymbTable_iter_count(arg1, iter)

def SymbTable_add_trigger(arg1: 'SymbTable_ptr const', trigger: 'SymbTableTriggerFun', action: 'SymbTableTriggerAction', arg: 'void *') -> "void":
    """SymbTable_add_trigger(SymbTable_ptr const arg1, SymbTableTriggerFun trigger, SymbTableTriggerAction action, void * arg)"""
    return _symb_table.SymbTable_add_trigger(arg1, trigger, action, arg)

def SymbTable_remove_trigger(arg1: 'SymbTable_ptr const', trigger: 'SymbTableTriggerFun', action: 'SymbTableTriggerAction') -> "void":
    """SymbTable_remove_trigger(SymbTable_ptr const arg1, SymbTableTriggerFun trigger, SymbTableTriggerAction action)"""
    return _symb_table.SymbTable_remove_trigger(arg1, trigger, action)

def SymbTable_iter_filter_i_symbols(arg1: 'SymbTable_ptr const', sym: 'node_ptr const', arg: 'void *') -> "boolean":
    """SymbTable_iter_filter_i_symbols(SymbTable_ptr const arg1, node_ptr const sym, void * arg) -> boolean"""
    return _symb_table.SymbTable_iter_filter_i_symbols(arg1, sym, arg)

def SymbTable_iter_filter_sf_i_symbols(arg1: 'SymbTable_ptr const', sym: 'node_ptr const', arg: 'void *') -> "boolean":
    """SymbTable_iter_filter_sf_i_symbols(SymbTable_ptr const arg1, node_ptr const sym, void * arg) -> boolean"""
    return _symb_table.SymbTable_iter_filter_sf_i_symbols(arg1, sym, arg)

def SymbTable_iter_filter_sf_symbols(arg1: 'SymbTable_ptr const', sym: 'node_ptr const', arg: 'void *') -> "boolean":
    """SymbTable_iter_filter_sf_symbols(SymbTable_ptr const arg1, node_ptr const sym, void * arg) -> boolean"""
    return _symb_table.SymbTable_iter_filter_sf_symbols(arg1, sym, arg)

def SymbTable_create_layer(arg1: 'SymbTable_ptr', layer_name: 'char const *', ins_policy: 'LayerInsertPolicy const') -> "SymbLayer_ptr":
    """SymbTable_create_layer(SymbTable_ptr arg1, char const * layer_name, LayerInsertPolicy const ins_policy) -> SymbLayer_ptr"""
    return _symb_table.SymbTable_create_layer(arg1, layer_name, ins_policy)

def SymbTable_remove_layer(arg1: 'SymbTable_ptr', layer: 'SymbLayer_ptr') -> "void":
    """SymbTable_remove_layer(SymbTable_ptr arg1, SymbLayer_ptr layer)"""
    return _symb_table.SymbTable_remove_layer(arg1, layer)

def SymbTable_get_layer(arg1: 'SymbTable_ptr const', layer_name: 'char const *') -> "SymbLayer_ptr":
    """SymbTable_get_layer(SymbTable_ptr const arg1, char const * layer_name) -> SymbLayer_ptr"""
    return _symb_table.SymbTable_get_layer(arg1, layer_name)

def SymbTable_rename_layer(arg1: 'SymbTable_ptr const', layer_name: 'char const *', new_name: 'char const *') -> "void":
    """SymbTable_rename_layer(SymbTable_ptr const arg1, char const * layer_name, char const * new_name)"""
    return _symb_table.SymbTable_rename_layer(arg1, layer_name, new_name)

def SymbTable_get_layers(arg1: 'SymbTable_ptr const') -> "NodeList_ptr":
    """SymbTable_get_layers(SymbTable_ptr const arg1) -> NodeList_ptr"""
    return _symb_table.SymbTable_get_layers(arg1)

def SymbTable_get_layers_sf_symbols(arg1: 'SymbTable_ptr', layer_names: 'array_t const *') -> "NodeList_ptr":
    """SymbTable_get_layers_sf_symbols(SymbTable_ptr arg1, array_t const * layer_names) -> NodeList_ptr"""
    return _symb_table.SymbTable_get_layers_sf_symbols(arg1, layer_names)

def SymbTable_get_layers_sf_vars(arg1: 'SymbTable_ptr', layer_names: 'array_t const *') -> "NodeList_ptr":
    """SymbTable_get_layers_sf_vars(SymbTable_ptr arg1, array_t const * layer_names) -> NodeList_ptr"""
    return _symb_table.SymbTable_get_layers_sf_vars(arg1, layer_names)

def SymbTable_get_layers_i_symbols(arg1: 'SymbTable_ptr', layer_names: 'array_t const *') -> "NodeList_ptr":
    """SymbTable_get_layers_i_symbols(SymbTable_ptr arg1, array_t const * layer_names) -> NodeList_ptr"""
    return _symb_table.SymbTable_get_layers_i_symbols(arg1, layer_names)

def SymbTable_get_layers_i_vars(arg1: 'SymbTable_ptr', layer_names: 'array_t const *') -> "NodeList_ptr":
    """SymbTable_get_layers_i_vars(SymbTable_ptr arg1, array_t const * layer_names) -> NodeList_ptr"""
    return _symb_table.SymbTable_get_layers_i_vars(arg1, layer_names)

def SymbTable_get_layers_sf_i_symbols(arg1: 'SymbTable_ptr', layer_names: 'array_t const *') -> "NodeList_ptr":
    """SymbTable_get_layers_sf_i_symbols(SymbTable_ptr arg1, array_t const * layer_names) -> NodeList_ptr"""
    return _symb_table.SymbTable_get_layers_sf_i_symbols(arg1, layer_names)

def SymbTable_get_layers_sf_i_vars(arg1: 'SymbTable_ptr', layer_names: 'array_t const *') -> "NodeList_ptr":
    """SymbTable_get_layers_sf_i_vars(SymbTable_ptr arg1, array_t const * layer_names) -> NodeList_ptr"""
    return _symb_table.SymbTable_get_layers_sf_i_vars(arg1, layer_names)

def SymbTable_get_vars_num(arg1: 'SymbTable_ptr const') -> "int":
    """SymbTable_get_vars_num(SymbTable_ptr const arg1) -> int"""
    return _symb_table.SymbTable_get_vars_num(arg1)

def SymbTable_get_state_vars_num(arg1: 'SymbTable_ptr const') -> "int":
    """SymbTable_get_state_vars_num(SymbTable_ptr const arg1) -> int"""
    return _symb_table.SymbTable_get_state_vars_num(arg1)

def SymbTable_get_frozen_vars_num(arg1: 'SymbTable_ptr const') -> "int":
    """SymbTable_get_frozen_vars_num(SymbTable_ptr const arg1) -> int"""
    return _symb_table.SymbTable_get_frozen_vars_num(arg1)

def SymbTable_get_input_vars_num(arg1: 'SymbTable_ptr const') -> "int":
    """SymbTable_get_input_vars_num(SymbTable_ptr const arg1) -> int"""
    return _symb_table.SymbTable_get_input_vars_num(arg1)

def SymbTable_get_defines_num(arg1: 'SymbTable_ptr const') -> "int":
    """SymbTable_get_defines_num(SymbTable_ptr const arg1) -> int"""
    return _symb_table.SymbTable_get_defines_num(arg1)

def SymbTable_get_array_defines_num(arg1: 'SymbTable_ptr const') -> "int":
    """SymbTable_get_array_defines_num(SymbTable_ptr const arg1) -> int"""
    return _symb_table.SymbTable_get_array_defines_num(arg1)

def SymbTable_get_parameters_num(arg1: 'SymbTable_ptr const') -> "int":
    """SymbTable_get_parameters_num(SymbTable_ptr const arg1) -> int"""
    return _symb_table.SymbTable_get_parameters_num(arg1)

def SymbTable_get_constants_num(arg1: 'SymbTable_ptr const') -> "int":
    """SymbTable_get_constants_num(SymbTable_ptr const arg1) -> int"""
    return _symb_table.SymbTable_get_constants_num(arg1)

def SymbTable_get_functions_num(arg1: 'SymbTable_ptr const') -> "int":
    """SymbTable_get_functions_num(SymbTable_ptr const arg1) -> int"""
    return _symb_table.SymbTable_get_functions_num(arg1)

def SymbTable_create_layer_class(arg1: 'SymbTable_ptr', class_name: 'char const *') -> "void":
    """SymbTable_create_layer_class(SymbTable_ptr arg1, char const * class_name)"""
    return _symb_table.SymbTable_create_layer_class(arg1, class_name)

def SymbTable_layer_class_exists(arg1: 'SymbTable_ptr', class_name: 'char const *') -> "boolean":
    """SymbTable_layer_class_exists(SymbTable_ptr arg1, char const * class_name) -> boolean"""
    return _symb_table.SymbTable_layer_class_exists(arg1, class_name)

def SymbTable_layer_add_to_class(arg1: 'SymbTable_ptr', layer_name: 'char const *', class_name: 'char const *') -> "void":
    """SymbTable_layer_add_to_class(SymbTable_ptr arg1, char const * layer_name, char const * class_name)"""
    return _symb_table.SymbTable_layer_add_to_class(arg1, layer_name, class_name)

def SymbTable_layer_remove_from_class(arg1: 'SymbTable_ptr', layer_name: 'char const *', class_name: 'char const *') -> "void":
    """SymbTable_layer_remove_from_class(SymbTable_ptr arg1, char const * layer_name, char const * class_name)"""
    return _symb_table.SymbTable_layer_remove_from_class(arg1, layer_name, class_name)

def SymbTable_get_class_layer_names(arg1: 'SymbTable_ptr', class_name: 'char const *') -> "array_t *":
    """SymbTable_get_class_layer_names(SymbTable_ptr arg1, char const * class_name) -> array_t *"""
    return _symb_table.SymbTable_get_class_layer_names(arg1, class_name)

def SymbTable_is_layer_in_class(arg1: 'SymbTable_ptr', layer_name: 'char const *', class_name: 'char const *') -> "boolean":
    """SymbTable_is_layer_in_class(SymbTable_ptr arg1, char const * layer_name, char const * class_name) -> boolean"""
    return _symb_table.SymbTable_is_layer_in_class(arg1, layer_name, class_name)

def SymbTable_set_default_layers_class_name(arg1: 'SymbTable_ptr', class_name: 'char const *') -> "void":
    """SymbTable_set_default_layers_class_name(SymbTable_ptr arg1, char const * class_name)"""
    return _symb_table.SymbTable_set_default_layers_class_name(arg1, class_name)

def SymbTable_get_default_layers_class_name(arg1: 'SymbTable_ptr const') -> "char const *":
    """SymbTable_get_default_layers_class_name(SymbTable_ptr const arg1) -> char const *"""
    return _symb_table.SymbTable_get_default_layers_class_name(arg1)

def SymbTable_get_var_type(arg1: 'SymbTable_ptr const', name: 'node_ptr const') -> "SymbType_ptr":
    """SymbTable_get_var_type(SymbTable_ptr const arg1, node_ptr const name) -> SymbType_ptr"""
    return _symb_table.SymbTable_get_var_type(arg1, name)

def SymbTable_get_define_body(arg1: 'SymbTable_ptr const', name: 'node_ptr const') -> "node_ptr":
    """SymbTable_get_define_body(SymbTable_ptr const arg1, node_ptr const name) -> node_ptr"""
    return _symb_table.SymbTable_get_define_body(arg1, name)

def SymbTable_get_function(arg1: 'SymbTable_ptr const', name: 'node_ptr const') -> "NFunction_ptr":
    """SymbTable_get_function(SymbTable_ptr const arg1, node_ptr const name) -> NFunction_ptr"""
    return _symb_table.SymbTable_get_function(arg1, name)

def SymbTable_get_actual_parameter(arg1: 'SymbTable_ptr const', name: 'node_ptr const') -> "node_ptr":
    """SymbTable_get_actual_parameter(SymbTable_ptr const arg1, node_ptr const name) -> node_ptr"""
    return _symb_table.SymbTable_get_actual_parameter(arg1, name)

def SymbTable_get_array_define_body(arg1: 'SymbTable_ptr const', name: 'node_ptr const') -> "node_ptr":
    """SymbTable_get_array_define_body(SymbTable_ptr const arg1, node_ptr const name) -> node_ptr"""
    return _symb_table.SymbTable_get_array_define_body(arg1, name)

def SymbTable_get_variable_array_type(arg1: 'SymbTable_ptr const', name: 'node_ptr const') -> "SymbType_ptr":
    """SymbTable_get_variable_array_type(SymbTable_ptr const arg1, node_ptr const name) -> SymbType_ptr"""
    return _symb_table.SymbTable_get_variable_array_type(arg1, name)

def SymbTable_get_define_flatten_body(arg1: 'SymbTable_ptr const', name: 'node_ptr const') -> "node_ptr":
    """SymbTable_get_define_flatten_body(SymbTable_ptr const arg1, node_ptr const name) -> node_ptr"""
    return _symb_table.SymbTable_get_define_flatten_body(arg1, name)

def SymbTable_get_flatten_actual_parameter(arg1: 'SymbTable_ptr const', name: 'node_ptr const') -> "node_ptr":
    """SymbTable_get_flatten_actual_parameter(SymbTable_ptr const arg1, node_ptr const name) -> node_ptr"""
    return _symb_table.SymbTable_get_flatten_actual_parameter(arg1, name)

def SymbTable_get_array_define_flatten_body(arg1: 'SymbTable_ptr const', name: 'node_ptr const') -> "node_ptr":
    """SymbTable_get_array_define_flatten_body(SymbTable_ptr const arg1, node_ptr const name) -> node_ptr"""
    return _symb_table.SymbTable_get_array_define_flatten_body(arg1, name)

def SymbTable_get_define_context(arg1: 'SymbTable_ptr const', name: 'node_ptr const') -> "node_ptr":
    """SymbTable_get_define_context(SymbTable_ptr const arg1, node_ptr const name) -> node_ptr"""
    return _symb_table.SymbTable_get_define_context(arg1, name)

def SymbTable_get_function_context(arg1: 'SymbTable_ptr const', name: 'node_ptr const') -> "node_ptr":
    """SymbTable_get_function_context(SymbTable_ptr const arg1, node_ptr const name) -> node_ptr"""
    return _symb_table.SymbTable_get_function_context(arg1, name)

def SymbTable_get_actual_parameter_context(arg1: 'SymbTable_ptr const', name: 'node_ptr const') -> "node_ptr":
    """SymbTable_get_actual_parameter_context(SymbTable_ptr const arg1, node_ptr const name) -> node_ptr"""
    return _symb_table.SymbTable_get_actual_parameter_context(arg1, name)

def SymbTable_get_array_define_context(arg1: 'SymbTable_ptr const', name: 'node_ptr const') -> "node_ptr":
    """SymbTable_get_array_define_context(SymbTable_ptr const arg1, node_ptr const name) -> node_ptr"""
    return _symb_table.SymbTable_get_array_define_context(arg1, name)

def SymbTable_get_symbol_category(arg1: 'SymbTable_ptr const', name: 'node_ptr const') -> "SymbCategory":
    """SymbTable_get_symbol_category(SymbTable_ptr const arg1, node_ptr const name) -> SymbCategory"""
    return _symb_table.SymbTable_get_symbol_category(arg1, name)

def SymbTable_is_symbol_state_var(arg1: 'SymbTable_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbTable_is_symbol_state_var(SymbTable_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbTable_is_symbol_state_var(arg1, name)

def SymbTable_is_symbol_frozen_var(arg1: 'SymbTable_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbTable_is_symbol_frozen_var(SymbTable_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbTable_is_symbol_frozen_var(arg1, name)

def SymbTable_is_symbol_state_frozen_var(arg1: 'SymbTable_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbTable_is_symbol_state_frozen_var(SymbTable_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbTable_is_symbol_state_frozen_var(arg1, name)

def SymbTable_is_symbol_input_var(arg1: 'SymbTable_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbTable_is_symbol_input_var(SymbTable_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbTable_is_symbol_input_var(arg1, name)

def SymbTable_is_symbol_var(arg1: 'SymbTable_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbTable_is_symbol_var(SymbTable_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbTable_is_symbol_var(arg1, name)

def SymbTable_is_symbol_bool_var(arg1: 'SymbTable_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbTable_is_symbol_bool_var(SymbTable_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbTable_is_symbol_bool_var(arg1, name)

def SymbTable_is_symbol_declared(arg1: 'SymbTable_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbTable_is_symbol_declared(SymbTable_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbTable_is_symbol_declared(arg1, name)

def SymbTable_is_symbol_define(arg1: 'SymbTable_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbTable_is_symbol_define(SymbTable_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbTable_is_symbol_define(arg1, name)

def SymbTable_is_symbol_function(arg1: 'SymbTable_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbTable_is_symbol_function(SymbTable_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbTable_is_symbol_function(arg1, name)

def SymbTable_is_symbol_parameter(arg1: 'SymbTable_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbTable_is_symbol_parameter(SymbTable_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbTable_is_symbol_parameter(arg1, name)

def SymbTable_is_symbol_array_define(arg1: 'SymbTable_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbTable_is_symbol_array_define(SymbTable_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbTable_is_symbol_array_define(arg1, name)

def SymbTable_is_symbol_variable_array(arg1: 'SymbTable_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbTable_is_symbol_variable_array(SymbTable_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbTable_is_symbol_variable_array(arg1, name)

def SymbTable_is_symbol_constant(arg1: 'SymbTable_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbTable_is_symbol_constant(SymbTable_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbTable_is_symbol_constant(arg1, name)

def SymbTable_is_var_finite(arg1: 'SymbTable_ptr const', name: 'node_ptr const') -> "boolean":
    """SymbTable_is_var_finite(SymbTable_ptr const arg1, node_ptr const name) -> boolean"""
    return _symb_table.SymbTable_is_var_finite(arg1, name)

def SymbTable_list_contains_input_var(arg1: 'SymbTable_ptr const', var_list: 'NodeList_ptr const') -> "boolean":
    """SymbTable_list_contains_input_var(SymbTable_ptr const arg1, NodeList_ptr const var_list) -> boolean"""
    return _symb_table.SymbTable_list_contains_input_var(arg1, var_list)

def SymbTable_list_contains_state_frozen_var(arg1: 'SymbTable_ptr const', var_list: 'NodeList_ptr const') -> "boolean":
    """SymbTable_list_contains_state_frozen_var(SymbTable_ptr const arg1, NodeList_ptr const var_list) -> boolean"""
    return _symb_table.SymbTable_list_contains_state_frozen_var(arg1, var_list)

def SymbTable_list_contains_undef_var(arg1: 'SymbTable_ptr const', var_list: 'NodeList_ptr const') -> "boolean":
    """SymbTable_list_contains_undef_var(SymbTable_ptr const arg1, NodeList_ptr const var_list) -> boolean"""
    return _symb_table.SymbTable_list_contains_undef_var(arg1, var_list)

def SymbTable_contains_infinite_precision_variables(arg1: 'SymbTable_ptr const') -> "boolean":
    """SymbTable_contains_infinite_precision_variables(SymbTable_ptr const arg1) -> boolean"""
    return _symb_table.SymbTable_contains_infinite_precision_variables(arg1)

def SymbTable_variable_get_layer(arg1: 'SymbTable_ptr', name: 'node_ptr') -> "SymbLayer_ptr":
    """SymbTable_variable_get_layer(SymbTable_ptr arg1, node_ptr name) -> SymbLayer_ptr"""
    return _symb_table.SymbTable_variable_get_layer(arg1, name)

def SymbTable_define_get_layer(arg1: 'SymbTable_ptr', name: 'node_ptr') -> "SymbLayer_ptr":
    """SymbTable_define_get_layer(SymbTable_ptr arg1, node_ptr name) -> SymbLayer_ptr"""
    return _symb_table.SymbTable_define_get_layer(arg1, name)

def SymbTable_symbol_get_layer(arg1: 'SymbTable_ptr', name: 'node_ptr') -> "SymbLayer_ptr":
    """SymbTable_symbol_get_layer(SymbTable_ptr arg1, node_ptr name) -> SymbLayer_ptr"""
    return _symb_table.SymbTable_symbol_get_layer(arg1, name)

def SymbTable_function_get_layer(arg1: 'SymbTable_ptr', name: 'node_ptr') -> "SymbLayer_ptr":
    """SymbTable_function_get_layer(SymbTable_ptr arg1, node_ptr name) -> SymbLayer_ptr"""
    return _symb_table.SymbTable_function_get_layer(arg1, name)

def SymbTable_get_determinization_var_name(arg1: 'SymbTable_ptr const') -> "node_ptr":
    """SymbTable_get_determinization_var_name(SymbTable_ptr const arg1) -> node_ptr"""
    return _symb_table.SymbTable_get_determinization_var_name(arg1)

def SymbTable_get_fresh_symbol_name(arg1: 'SymbTable_ptr', tplate: 'char const *') -> "node_ptr":
    """SymbTable_get_fresh_symbol_name(SymbTable_ptr arg1, char const * tplate) -> node_ptr"""
    return _symb_table.SymbTable_get_fresh_symbol_name(arg1, tplate)

def SymbTable_get_simplification_hash(arg1: 'SymbTable_ptr') -> "hash_ptr":
    """SymbTable_get_simplification_hash(SymbTable_ptr arg1) -> hash_ptr"""
    return _symb_table.SymbTable_get_simplification_hash(arg1)

def SymbTable_get_class_of_layer(arg1: 'SymbTable_ptr const', layer_name: 'char const *') -> "char const *":
    """SymbTable_get_class_of_layer(SymbTable_ptr const arg1, char const * layer_name) -> char const *"""
    return _symb_table.SymbTable_get_class_of_layer(arg1, layer_name)

def SymbTable_resolve_symbol(arg1: 'SymbTable_ptr', expr: 'node_ptr', context: 'node_ptr') -> "ResolveSymbol_ptr":
    """SymbTable_resolve_symbol(SymbTable_ptr arg1, node_ptr expr, node_ptr context) -> ResolveSymbol_ptr"""
    return _symb_table.SymbTable_resolve_symbol(arg1, expr, context)

def SymbTable_copy(arg1: 'SymbTable_ptr', blacklist: 'Set_t') -> "SymbTable_ptr":
    """SymbTable_copy(SymbTable_ptr arg1, Set_t blacklist) -> SymbTable_ptr"""
    return _symb_table.SymbTable_copy(arg1, blacklist)
SYMB_TYPE_NONE = _symb_table.SYMB_TYPE_NONE
SYMB_TYPE_STATEMENT = _symb_table.SYMB_TYPE_STATEMENT
SYMB_TYPE_BOOLEAN = _symb_table.SYMB_TYPE_BOOLEAN
SYMB_TYPE_ENUM = _symb_table.SYMB_TYPE_ENUM
SYMB_TYPE_INTEGER = _symb_table.SYMB_TYPE_INTEGER
SYMB_TYPE_REAL = _symb_table.SYMB_TYPE_REAL
SYMB_TYPE_SIGNED_WORD = _symb_table.SYMB_TYPE_SIGNED_WORD
SYMB_TYPE_UNSIGNED_WORD = _symb_table.SYMB_TYPE_UNSIGNED_WORD
SYMB_TYPE_WORDARRAY = _symb_table.SYMB_TYPE_WORDARRAY
SYMB_TYPE_ARRAY = _symb_table.SYMB_TYPE_ARRAY
SYMB_TYPE_STRING = _symb_table.SYMB_TYPE_STRING
SYMB_TYPE_SET_BOOL = _symb_table.SYMB_TYPE_SET_BOOL
SYMB_TYPE_SET_INT = _symb_table.SYMB_TYPE_SET_INT
SYMB_TYPE_SET_SYMB = _symb_table.SYMB_TYPE_SET_SYMB
SYMB_TYPE_SET_INT_SYMB = _symb_table.SYMB_TYPE_SET_INT_SYMB
SYMB_TYPE_ERROR = _symb_table.SYMB_TYPE_ERROR
ENUM_TYPE_PURE_INT = _symb_table.ENUM_TYPE_PURE_INT
ENUM_TYPE_PURE_SYMBOLIC = _symb_table.ENUM_TYPE_PURE_SYMBOLIC
ENUM_TYPE_INT_SYMBOLIC = _symb_table.ENUM_TYPE_INT_SYMBOLIC

def SymbType_create(tag: 'SymbTypeTag', body: 'node_ptr') -> "SymbType_ptr":
    """SymbType_create(SymbTypeTag tag, node_ptr body) -> SymbType_ptr"""
    return _symb_table.SymbType_create(tag, body)

def SymbType_create_array(subtype: 'SymbType_ptr', lower_bound: 'int', upper_bound: 'int') -> "SymbType_ptr":
    """SymbType_create_array(SymbType_ptr subtype, int lower_bound, int upper_bound) -> SymbType_ptr"""
    return _symb_table.SymbType_create_array(subtype, lower_bound, upper_bound)

def SymbType_destroy(arg1: 'SymbType_ptr') -> "void":
    """SymbType_destroy(SymbType_ptr arg1)"""
    return _symb_table.SymbType_destroy(arg1)

def SymbType_copy(arg1: 'SymbType_ptr const') -> "SymbType_ptr":
    """SymbType_copy(SymbType_ptr const arg1) -> SymbType_ptr"""
    return _symb_table.SymbType_copy(arg1)

def SymbType_get_tag(arg1: 'SymbType_ptr const') -> "SymbTypeTag":
    """SymbType_get_tag(SymbType_ptr const arg1) -> SymbTypeTag"""
    return _symb_table.SymbType_get_tag(arg1)

def SymbType_is_enum(arg1: 'SymbType_ptr const') -> "boolean":
    """SymbType_is_enum(SymbType_ptr const arg1) -> boolean"""
    return _symb_table.SymbType_is_enum(arg1)

def SymbType_is_boolean(arg1: 'SymbType_ptr const') -> "boolean":
    """SymbType_is_boolean(SymbType_ptr const arg1) -> boolean"""
    return _symb_table.SymbType_is_boolean(arg1)

def SymbType_is_integer(arg1: 'SymbType_ptr const') -> "boolean":
    """SymbType_is_integer(SymbType_ptr const arg1) -> boolean"""
    return _symb_table.SymbType_is_integer(arg1)

def SymbType_is_real(arg1: 'SymbType_ptr const') -> "boolean":
    """SymbType_is_real(SymbType_ptr const arg1) -> boolean"""
    return _symb_table.SymbType_is_real(arg1)

def SymbType_is_pure_int_enum(arg1: 'SymbType_ptr const') -> "boolean":
    """SymbType_is_pure_int_enum(SymbType_ptr const arg1) -> boolean"""
    return _symb_table.SymbType_is_pure_int_enum(arg1)

def SymbType_is_pure_symbolic_enum(arg1: 'SymbType_ptr const') -> "boolean":
    """SymbType_is_pure_symbolic_enum(SymbType_ptr const arg1) -> boolean"""
    return _symb_table.SymbType_is_pure_symbolic_enum(arg1)

def SymbType_is_int_symbolic_enum(arg1: 'SymbType_ptr const') -> "boolean":
    """SymbType_is_int_symbolic_enum(SymbType_ptr const arg1) -> boolean"""
    return _symb_table.SymbType_is_int_symbolic_enum(arg1)

def SymbType_is_word_1(arg1: 'SymbType_ptr const') -> "boolean":
    """SymbType_is_word_1(SymbType_ptr const arg1) -> boolean"""
    return _symb_table.SymbType_is_word_1(arg1)

def SymbType_is_unsigned_word(arg1: 'SymbType_ptr const') -> "boolean":
    """SymbType_is_unsigned_word(SymbType_ptr const arg1) -> boolean"""
    return _symb_table.SymbType_is_unsigned_word(arg1)

def SymbType_is_signed_word(arg1: 'SymbType_ptr const') -> "boolean":
    """SymbType_is_signed_word(SymbType_ptr const arg1) -> boolean"""
    return _symb_table.SymbType_is_signed_word(arg1)

def SymbType_is_word(arg1: 'SymbType_ptr const') -> "boolean":
    """SymbType_is_word(SymbType_ptr const arg1) -> boolean"""
    return _symb_table.SymbType_is_word(arg1)

def SymbType_is_set(arg1: 'SymbType_ptr const') -> "boolean":
    """SymbType_is_set(SymbType_ptr const arg1) -> boolean"""
    return _symb_table.SymbType_is_set(arg1)

def SymbType_is_string(arg1: 'SymbType_ptr const') -> "boolean":
    """SymbType_is_string(SymbType_ptr const arg1) -> boolean"""
    return _symb_table.SymbType_is_string(arg1)

def SymbType_is_error(arg1: 'SymbType_ptr const') -> "boolean":
    """SymbType_is_error(SymbType_ptr const arg1) -> boolean"""
    return _symb_table.SymbType_is_error(arg1)

def SymbType_is_statement(arg1: 'SymbType_ptr const') -> "boolean":
    """SymbType_is_statement(SymbType_ptr const arg1) -> boolean"""
    return _symb_table.SymbType_is_statement(arg1)

def SymbType_is_infinite_precision(arg1: 'SymbType_ptr const') -> "boolean":
    """SymbType_is_infinite_precision(SymbType_ptr const arg1) -> boolean"""
    return _symb_table.SymbType_is_infinite_precision(arg1)

def SymbType_is_array(arg1: 'SymbType_ptr const') -> "boolean":
    """SymbType_is_array(SymbType_ptr const arg1) -> boolean"""
    return _symb_table.SymbType_is_array(arg1)

def SymbType_is_wordarray(arg1: 'SymbType_ptr const') -> "boolean":
    """SymbType_is_wordarray(SymbType_ptr const arg1) -> boolean"""
    return _symb_table.SymbType_is_wordarray(arg1)

def SymbType_calculate_type_size(arg1: 'SymbType_ptr const') -> "int":
    """SymbType_calculate_type_size(SymbType_ptr const arg1) -> int"""
    return _symb_table.SymbType_calculate_type_size(arg1)

def SymbType_generate_all_word_values(arg1: 'SymbType_ptr const') -> "node_ptr":
    """SymbType_generate_all_word_values(SymbType_ptr const arg1) -> node_ptr"""
    return _symb_table.SymbType_generate_all_word_values(arg1)

def SymbType_get_word_width(arg1: 'SymbType_ptr const') -> "int":
    """SymbType_get_word_width(SymbType_ptr const arg1) -> int"""
    return _symb_table.SymbType_get_word_width(arg1)

def SymbType_get_word_line_number(arg1: 'SymbType_ptr const') -> "int":
    """SymbType_get_word_line_number(SymbType_ptr const arg1) -> int"""
    return _symb_table.SymbType_get_word_line_number(arg1)

def SymbType_get_wordarray_awidth(arg1: 'SymbType_ptr const') -> "int":
    """SymbType_get_wordarray_awidth(SymbType_ptr const arg1) -> int"""
    return _symb_table.SymbType_get_wordarray_awidth(arg1)

def SymbType_get_wordarray_vwidth(arg1: 'SymbType_ptr const') -> "int":
    """SymbType_get_wordarray_vwidth(SymbType_ptr const arg1) -> int"""
    return _symb_table.SymbType_get_wordarray_vwidth(arg1)

def SymbType_get_enum_type_values(arg1: 'SymbType_ptr const') -> "node_ptr":
    """SymbType_get_enum_type_values(SymbType_ptr const arg1) -> node_ptr"""
    return _symb_table.SymbType_get_enum_type_values(arg1)

def SymbType_get_array_subtype(arg1: 'SymbType_ptr const') -> "SymbType_ptr":
    """SymbType_get_array_subtype(SymbType_ptr const arg1) -> SymbType_ptr"""
    return _symb_table.SymbType_get_array_subtype(arg1)

def SymbType_get_array_lower_bound(arg1: 'SymbType_ptr const') -> "int":
    """SymbType_get_array_lower_bound(SymbType_ptr const arg1) -> int"""
    return _symb_table.SymbType_get_array_lower_bound(arg1)

def SymbType_get_array_upper_bound(arg1: 'SymbType_ptr const') -> "int":
    """SymbType_get_array_upper_bound(SymbType_ptr const arg1) -> int"""
    return _symb_table.SymbType_get_array_upper_bound(arg1)

def SymbType_print(arg1: 'SymbType_ptr const', output_stream: 'FILE *') -> "void":
    """SymbType_print(SymbType_ptr const arg1, FILE * output_stream)"""
    return _symb_table.SymbType_print(arg1, output_stream)

def SymbType_sprint(arg1: 'SymbType_ptr const') -> "char *":
    """SymbType_sprint(SymbType_ptr const arg1) -> char *"""
    return _symb_table.SymbType_sprint(arg1)

def SymbType_is_back_comp(type: 'SymbType_ptr const') -> "boolean":
    """SymbType_is_back_comp(SymbType_ptr const type) -> boolean"""
    return _symb_table.SymbType_is_back_comp(type)

def SymbType_get_greater(type1: 'SymbType_ptr const', type2: 'SymbType_ptr const') -> "SymbType_ptr":
    """SymbType_get_greater(SymbType_ptr const type1, SymbType_ptr const type2) -> SymbType_ptr"""
    return _symb_table.SymbType_get_greater(type1, type2)

def SymbType_make_set_type(arg1: 'SymbType_ptr const') -> "SymbType_ptr":
    """SymbType_make_set_type(SymbType_ptr const arg1) -> SymbType_ptr"""
    return _symb_table.SymbType_make_set_type(arg1)

def SymbType_make_from_set_type(arg1: 'SymbType_ptr const') -> "SymbType_ptr":
    """SymbType_make_from_set_type(SymbType_ptr const arg1) -> SymbType_ptr"""
    return _symb_table.SymbType_make_from_set_type(arg1)

def SymbType_make_memory_shared(arg1: 'SymbType_ptr const') -> "SymbType_ptr":
    """SymbType_make_memory_shared(SymbType_ptr const arg1) -> SymbType_ptr"""
    return _symb_table.SymbType_make_memory_shared(arg1)

def SymbType_convert_right_to_left(leftType: 'SymbType_ptr', rightType: 'SymbType_ptr') -> "SymbType_ptr":
    """SymbType_convert_right_to_left(SymbType_ptr leftType, SymbType_ptr rightType) -> SymbType_ptr"""
    return _symb_table.SymbType_convert_right_to_left(leftType, rightType)

def SymbType_get_minimal_common(type1: 'SymbType_ptr', type2: 'SymbType_ptr') -> "SymbType_ptr":
    """SymbType_get_minimal_common(SymbType_ptr type1, SymbType_ptr type2) -> SymbType_ptr"""
    return _symb_table.SymbType_get_minimal_common(type1, type2)

def SymbType_is_memory_shared(arg1: 'SymbType_ptr') -> "boolean":
    """SymbType_is_memory_shared(SymbType_ptr arg1) -> boolean"""
    return _symb_table.SymbType_is_memory_shared(arg1)

def SymbType_equals(arg1: 'SymbType_ptr', oth: 'SymbType_ptr') -> "boolean":
    """SymbType_equals(SymbType_ptr arg1, SymbType_ptr oth) -> boolean"""
    return _symb_table.SymbType_equals(arg1, oth)

def gen_iter(arg1: 'SymbLayer_ptr const', mask: 'unsigned int') -> "SymbLayerIter":
    """gen_iter(SymbLayer_ptr const arg1, unsigned int mask) -> SymbLayerIter"""
    return _symb_table.gen_iter(arg1, mask)

def node2layer(node: 'node_ptr') -> "SymbLayer_ptr":
    """node2layer(node_ptr node) -> SymbLayer_ptr"""
    return _symb_table.node2layer(node)
# This file is compatible with both classic and new-style classes.


