# 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, '_compile')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_compile')
    _compile = 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('_compile', [dirname(__file__)])
        except ImportError:
            import _compile
            return _compile
        if fp is not None:
            try:
                _mod = imp.load_module('_compile', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _compile = swig_import_helper()
    del swig_import_helper
else:
    import _compile
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 = _compile.PRIuPTR
PRIdPTR = _compile.PRIdPTR
LLU = _compile.LLU
LLO = _compile.LLO
LLX = _compile.LLX
false = _compile.false
true = _compile.true
OUTCOME_GENERIC_ERROR = _compile.OUTCOME_GENERIC_ERROR
OUTCOME_PARSER_ERROR = _compile.OUTCOME_PARSER_ERROR
OUTCOME_SYNTAX_ERROR = _compile.OUTCOME_SYNTAX_ERROR
OUTCOME_FILE_ERROR = _compile.OUTCOME_FILE_ERROR
OUTCOME_SUCCESS_REQUIRED_HELP = _compile.OUTCOME_SUCCESS_REQUIRED_HELP
OUTCOME_SUCCESS = _compile.OUTCOME_SUCCESS
State_Variables_Instantiation_Mode = _compile.State_Variables_Instantiation_Mode
Frozen_Variables_Instantiation_Mode = _compile.Frozen_Variables_Instantiation_Mode
Input_Variables_Instantiation_Mode = _compile.Input_Variables_Instantiation_Mode
ST_Notype = _compile.ST_Notype
ST_Ctl = _compile.ST_Ctl
ST_Ltl = _compile.ST_Ltl
ST_Invar = _compile.ST_Invar
ST_Compute = _compile.ST_Compute
SS_Nostatus = _compile.SS_Nostatus
SS_Unchecked = _compile.SS_Unchecked
SS_True = _compile.SS_True
SS_False = _compile.SS_False
SS_Wrong = _compile.SS_Wrong
SS_Number = _compile.SS_Number
MODEL_LAYER_NAME = _compile.MODEL_LAYER_NAME
DETERM_LAYER_NAME = _compile.DETERM_LAYER_NAME
INLINING_LAYER_NAME = _compile.INLINING_LAYER_NAME
PROCESS_SELECTOR_VAR_NAME = _compile.PROCESS_SELECTOR_VAR_NAME
RUNNING_SYMBOL = _compile.RUNNING_SYMBOL
MODEL_LAYERS_CLASS = _compile.MODEL_LAYERS_CLASS
ARTIFACTS_LAYERS_CLASS = _compile.ARTIFACTS_LAYERS_CLASS

def Compile_init() -> "void":
    """Compile_init()"""
    return _compile.Compile_init()

def Compile_init_cmd() -> "void":
    """Compile_init_cmd()"""
    return _compile.Compile_init_cmd()

def Compile_quit() -> "void":
    """Compile_quit()"""
    return _compile.Compile_quit()

def CompileFlatten_init_flattener() -> "void":
    """CompileFlatten_init_flattener()"""
    return _compile.CompileFlatten_init_flattener()

def CompileFlatten_quit_flattener() -> "void":
    """CompileFlatten_quit_flattener()"""
    return _compile.CompileFlatten_quit_flattener()

def CompileFlatten_hash_module(parsed_module: 'node_ptr') -> "void":
    """CompileFlatten_hash_module(node_ptr parsed_module)"""
    return _compile.CompileFlatten_hash_module(parsed_module)

def Compile_FlattenHierarchy(symb_table: 'SymbTable_ptr const', layer: 'SymbLayer_ptr', arg3: 'node_ptr', arg4: 'node_ptr', arg5: 'node_ptr', create_process_variable: 'boolean', calc_vars_constr: 'boolean', hrc_result: 'HrcNode_ptr') -> "FlatHierarchy_ptr":
    """Compile_FlattenHierarchy(SymbTable_ptr const symb_table, SymbLayer_ptr layer, node_ptr arg3, node_ptr arg4, node_ptr arg5, boolean create_process_variable, boolean calc_vars_constr, HrcNode_ptr hrc_result) -> FlatHierarchy_ptr"""
    return _compile.Compile_FlattenHierarchy(symb_table, layer, arg3, arg4, arg5, create_process_variable, calc_vars_constr, hrc_result)

def Compile_CheckAssigns(arg1: 'SymbTable_ptr const', arg2: 'node_ptr') -> "void":
    """Compile_CheckAssigns(SymbTable_ptr const arg1, node_ptr arg2)"""
    return _compile.Compile_CheckAssigns(arg1, arg2)

def Compile_check_case(expr: 'node_ptr') -> "void":
    """Compile_check_case(node_ptr expr)"""
    return _compile.Compile_check_case(expr)

def Compile_check_next(st: 'SymbTable_ptr const', expr: 'node_ptr', context: 'node_ptr', is_one_next_allowed: 'boolean') -> "void":
    """Compile_check_next(SymbTable_ptr const st, node_ptr expr, node_ptr context, boolean is_one_next_allowed)"""
    return _compile.Compile_check_next(st, expr, context, is_one_next_allowed)

def Compile_check_input_next(st: 'SymbTable_ptr const', expr: 'node_ptr', context: 'node_ptr') -> "void":
    """Compile_check_input_next(SymbTable_ptr const st, node_ptr expr, node_ptr context)"""
    return _compile.Compile_check_input_next(st, expr, context)

def CompileFlatten_concat_contexts(ctx1: 'node_ptr', ctx2: 'node_ptr') -> "node_ptr":
    """CompileFlatten_concat_contexts(node_ptr ctx1, node_ptr ctx2) -> node_ptr"""
    return _compile.CompileFlatten_concat_contexts(ctx1, ctx2)

def CompileFlatten_expand_range(a: 'int', b: 'int') -> "node_ptr":
    """CompileFlatten_expand_range(int a, int b) -> node_ptr"""
    return _compile.CompileFlatten_expand_range(a, b)

def CompileFlatten_resolve_number(symb_table: 'SymbTable_ptr', n: 'node_ptr', context: 'node_ptr') -> "node_ptr":
    """CompileFlatten_resolve_number(SymbTable_ptr symb_table, node_ptr n, node_ptr context) -> node_ptr"""
    return _compile.CompileFlatten_resolve_number(symb_table, n, context)

def CompileFlatten_resolve_define_chains(symb_table: 'SymbTable_ptr const', expr: 'node_ptr', context: 'node_ptr') -> "node_ptr":
    """CompileFlatten_resolve_define_chains(SymbTable_ptr const symb_table, node_ptr expr, node_ptr context) -> node_ptr"""
    return _compile.CompileFlatten_resolve_define_chains(symb_table, expr, context)

def sym_intern(arg1: 'char *') -> "node_ptr":
    """sym_intern(char * arg1) -> node_ptr"""
    return _compile.sym_intern(arg1)

def insert_module_hash(x: 'node_ptr', y: 'node_ptr') -> "void":
    """insert_module_hash(node_ptr x, node_ptr y)"""
    return _compile.insert_module_hash(x, y)

def lookup_module_hash(x: 'node_ptr') -> "node_ptr":
    """lookup_module_hash(node_ptr x) -> node_ptr"""
    return _compile.lookup_module_hash(x)

def compileCheckForInputVars(arg1: 'SymbTable_ptr', arg2: 'node_ptr', arg3: 'node_ptr', arg4: 'node_ptr', arg5: 'node_ptr', hierarchy: 'FlatHierarchy_ptr') -> "void":
    """compileCheckForInputVars(SymbTable_ptr arg1, node_ptr arg2, node_ptr arg3, node_ptr arg4, node_ptr arg5, FlatHierarchy_ptr hierarchy)"""
    return _compile.compileCheckForInputVars(arg1, arg2, arg3, arg4, arg5, hierarchy)

def cmp_struct_get_read_model(cmp: 'cmp_struct') -> "int":
    """cmp_struct_get_read_model(cmp_struct cmp) -> int"""
    return _compile.cmp_struct_get_read_model(cmp)

def cmp_struct_set_read_model(cmp: 'cmp_struct') -> "void":
    """cmp_struct_set_read_model(cmp_struct cmp)"""
    return _compile.cmp_struct_set_read_model(cmp)

def cmp_struct_unset_read_model(cmp: 'cmp_struct') -> "void":
    """cmp_struct_unset_read_model(cmp_struct cmp)"""
    return _compile.cmp_struct_unset_read_model(cmp)

def cmp_struct_get_hrc_built(cmp: 'cmp_struct') -> "int":
    """cmp_struct_get_hrc_built(cmp_struct cmp) -> int"""
    return _compile.cmp_struct_get_hrc_built(cmp)

def cmp_struct_set_hrc_built(cmp: 'cmp_struct') -> "void":
    """cmp_struct_set_hrc_built(cmp_struct cmp)"""
    return _compile.cmp_struct_set_hrc_built(cmp)

def cmp_struct_get_flatten_hrc(cmp: 'cmp_struct') -> "int":
    """cmp_struct_get_flatten_hrc(cmp_struct cmp) -> int"""
    return _compile.cmp_struct_get_flatten_hrc(cmp)

def cmp_struct_set_flatten_hrc(cmp: 'cmp_struct') -> "void":
    """cmp_struct_set_flatten_hrc(cmp_struct cmp)"""
    return _compile.cmp_struct_set_flatten_hrc(cmp)

def cmp_struct_get_encode_variables(cmp: 'cmp_struct') -> "int":
    """cmp_struct_get_encode_variables(cmp_struct cmp) -> int"""
    return _compile.cmp_struct_get_encode_variables(cmp)

def cmp_struct_set_encode_variables(cmp: 'cmp_struct') -> "void":
    """cmp_struct_set_encode_variables(cmp_struct cmp)"""
    return _compile.cmp_struct_set_encode_variables(cmp)

def cmp_struct_get_process_selector(cmp: 'cmp_struct') -> "int":
    """cmp_struct_get_process_selector(cmp_struct cmp) -> int"""
    return _compile.cmp_struct_get_process_selector(cmp)

def cmp_struct_set_process_selector(cmp: 'cmp_struct') -> "void":
    """cmp_struct_set_process_selector(cmp_struct cmp)"""
    return _compile.cmp_struct_set_process_selector(cmp)

def cmp_struct_get_build_frames(cmp: 'cmp_struct') -> "int":
    """cmp_struct_get_build_frames(cmp_struct cmp) -> int"""
    return _compile.cmp_struct_get_build_frames(cmp)

def cmp_struct_set_build_frames(cmp: 'cmp_struct') -> "void":
    """cmp_struct_set_build_frames(cmp_struct cmp)"""
    return _compile.cmp_struct_set_build_frames(cmp)

def cmp_struct_get_build_model(cmp: 'cmp_struct') -> "int":
    """cmp_struct_get_build_model(cmp_struct cmp) -> int"""
    return _compile.cmp_struct_get_build_model(cmp)

def cmp_struct_set_build_model(cmp: 'cmp_struct') -> "void":
    """cmp_struct_set_build_model(cmp_struct cmp)"""
    return _compile.cmp_struct_set_build_model(cmp)

def cmp_struct_get_build_flat_model(cmp: 'cmp_struct') -> "int":
    """cmp_struct_get_build_flat_model(cmp_struct cmp) -> int"""
    return _compile.cmp_struct_get_build_flat_model(cmp)

def cmp_struct_set_build_flat_model(cmp: 'cmp_struct') -> "void":
    """cmp_struct_set_build_flat_model(cmp_struct cmp)"""
    return _compile.cmp_struct_set_build_flat_model(cmp)

def cmp_struct_get_build_bool_model(cmp: 'cmp_struct') -> "int":
    """cmp_struct_get_build_bool_model(cmp_struct cmp) -> int"""
    return _compile.cmp_struct_get_build_bool_model(cmp)

def cmp_struct_set_build_bool_model(cmp: 'cmp_struct') -> "void":
    """cmp_struct_set_build_bool_model(cmp_struct cmp)"""
    return _compile.cmp_struct_set_build_bool_model(cmp)

def cmp_struct_get_fairness(cmp: 'cmp_struct') -> "int":
    """cmp_struct_get_fairness(cmp_struct cmp) -> int"""
    return _compile.cmp_struct_get_fairness(cmp)

def cmp_struct_set_fairness(cmp: 'cmp_struct') -> "void":
    """cmp_struct_set_fairness(cmp_struct cmp)"""
    return _compile.cmp_struct_set_fairness(cmp)

def cmp_struct_get_coi(cmp: 'cmp_struct') -> "int":
    """cmp_struct_get_coi(cmp_struct cmp) -> int"""
    return _compile.cmp_struct_get_coi(cmp)

def cmp_struct_set_coi(cmp: 'cmp_struct') -> "void":
    """cmp_struct_set_coi(cmp_struct cmp)"""
    return _compile.cmp_struct_set_coi(cmp)

def cmp_struct_get_bmc_init(cmp: 'cmp_struct') -> "int":
    """cmp_struct_get_bmc_init(cmp_struct cmp) -> int"""
    return _compile.cmp_struct_get_bmc_init(cmp)

def cmp_struct_set_bmc_init(cmp: 'cmp_struct') -> "void":
    """cmp_struct_set_bmc_init(cmp_struct cmp)"""
    return _compile.cmp_struct_set_bmc_init(cmp)

def cmp_struct_unset_bmc_init(cmp: 'cmp_struct') -> "void":
    """cmp_struct_unset_bmc_init(cmp_struct cmp)"""
    return _compile.cmp_struct_unset_bmc_init(cmp)

def cmp_struct_get_bmc_setup(cmp: 'cmp_struct') -> "int":
    """cmp_struct_get_bmc_setup(cmp_struct cmp) -> int"""
    return _compile.cmp_struct_get_bmc_setup(cmp)

def cmp_struct_set_bmc_setup(cmp: 'cmp_struct') -> "void":
    """cmp_struct_set_bmc_setup(cmp_struct cmp)"""
    return _compile.cmp_struct_set_bmc_setup(cmp)

def cmp_struct_unset_bmc_setup(cmp: 'cmp_struct') -> "void":
    """cmp_struct_unset_bmc_setup(cmp_struct cmp)"""
    return _compile.cmp_struct_unset_bmc_setup(cmp)

def Compile_FlattenSexp(symb_table: 'SymbTable_ptr const', arg2: 'node_ptr', arg3: 'node_ptr') -> "node_ptr":
    """Compile_FlattenSexp(SymbTable_ptr const symb_table, node_ptr arg2, node_ptr arg3) -> node_ptr"""
    return _compile.Compile_FlattenSexp(symb_table, arg2, arg3)

def Compile_FlattenSexpExpandDefine(symb_table: 'SymbTable_ptr const', arg2: 'node_ptr', arg3: 'node_ptr') -> "node_ptr":
    """Compile_FlattenSexpExpandDefine(SymbTable_ptr const symb_table, node_ptr arg2, node_ptr arg3) -> node_ptr"""
    return _compile.Compile_FlattenSexpExpandDefine(symb_table, arg2, arg3)

def Compile_WriteFlattenModel(out: 'FILE *', st: 'SymbTable_ptr const', layer_names: 'array_t const *', fsm_name: 'char const *', hierarchy: 'FlatHierarchy_ptr', force_flattening: 'boolean') -> "void":
    """Compile_WriteFlattenModel(FILE * out, SymbTable_ptr const st, array_t const * layer_names, char const * fsm_name, FlatHierarchy_ptr hierarchy, boolean force_flattening)"""
    return _compile.Compile_WriteFlattenModel(out, st, layer_names, fsm_name, hierarchy, force_flattening)

def Compile_WriteRestrictedFlattenModel(out: 'FILE *', st: 'SymbTable_ptr const', layer_names: 'array_t const *', fsm_name: 'char const *', hierarchy: 'FlatHierarchy_ptr', force_flattening: 'boolean') -> "void":
    """Compile_WriteRestrictedFlattenModel(FILE * out, SymbTable_ptr const st, array_t const * layer_names, char const * fsm_name, FlatHierarchy_ptr hierarchy, boolean force_flattening)"""
    return _compile.Compile_WriteRestrictedFlattenModel(out, st, layer_names, fsm_name, hierarchy, force_flattening)

def Compile_WriteObfuscatedFlattenModel(out: 'FILE *', st: 'SymbTable_ptr const', layer_names: 'array_t const *', fsm_name: 'char const *', hierarchy: 'FlatHierarchy_ptr', print_map: 'boolean', force_flattening: 'boolean') -> "void":
    """Compile_WriteObfuscatedFlattenModel(FILE * out, SymbTable_ptr const st, array_t const * layer_names, char const * fsm_name, FlatHierarchy_ptr hierarchy, boolean print_map, boolean force_flattening)"""
    return _compile.Compile_WriteObfuscatedFlattenModel(out, st, layer_names, fsm_name, hierarchy, print_map, force_flattening)

def Compile_WriteFlattenFsm(out: 'FILE *', symb_table: 'SymbTable_ptr const', layer_names: 'array_t const *', fsm_name: 'char const *', hierarchy: 'FlatHierarchy_ptr', force_flattening: 'boolean') -> "void":
    """Compile_WriteFlattenFsm(FILE * out, SymbTable_ptr const symb_table, array_t const * layer_names, char const * fsm_name, FlatHierarchy_ptr hierarchy, boolean force_flattening)"""
    return _compile.Compile_WriteFlattenFsm(out, symb_table, layer_names, fsm_name, hierarchy, force_flattening)

def Compile_WriteFlattenModel_udg(out: 'FILE *', st: 'SymbTable_ptr const', layer_names: 'array_t const *', fsm_name: 'char const *', hierarchy: 'FlatHierarchy_ptr') -> "void":
    """Compile_WriteFlattenModel_udg(FILE * out, SymbTable_ptr const st, array_t const * layer_names, char const * fsm_name, FlatHierarchy_ptr hierarchy)"""
    return _compile.Compile_WriteFlattenModel_udg(out, st, layer_names, fsm_name, hierarchy)

def Compile_WriteFlattenSpecs(out: 'FILE *', st: 'SymbTable_ptr const', hierarchy: 'FlatHierarchy_ptr', force_flattening: 'boolean') -> "void":
    """Compile_WriteFlattenSpecs(FILE * out, SymbTable_ptr const st, FlatHierarchy_ptr hierarchy, boolean force_flattening)"""
    return _compile.Compile_WriteFlattenSpecs(out, st, hierarchy, force_flattening)

def Compile_WriteBoolModel(out: 'FILE *', enc: 'BddEnc_ptr', layers: 'NodeList_ptr', fsm_name: 'char const *', bool_sexp_fsm: 'BoolSexpFsm_ptr', force_flattening: 'boolean') -> "void":
    """Compile_WriteBoolModel(FILE * out, BddEnc_ptr enc, NodeList_ptr layers, char const * fsm_name, BoolSexpFsm_ptr bool_sexp_fsm, boolean force_flattening)"""
    return _compile.Compile_WriteBoolModel(out, enc, layers, fsm_name, bool_sexp_fsm, force_flattening)

def Compile_WriteBoolFsm(out: 'FILE *', symb_table: 'SymbTable_ptr const', layers: 'NodeList_ptr', fsm_name: 'char const *', bool_sexp_fsm: 'BoolSexpFsm_ptr', force_flattening: 'boolean') -> "void":
    """Compile_WriteBoolFsm(FILE * out, SymbTable_ptr const symb_table, NodeList_ptr layers, char const * fsm_name, BoolSexpFsm_ptr bool_sexp_fsm, boolean force_flattening)"""
    return _compile.Compile_WriteBoolFsm(out, symb_table, layers, fsm_name, bool_sexp_fsm, force_flattening)

def Compile_WriteBoolSpecs(out: 'FILE *', enc: 'BddEnc_ptr', hierarchy: 'FlatHierarchy_ptr') -> "void":
    """Compile_WriteBoolSpecs(FILE * out, BddEnc_ptr enc, FlatHierarchy_ptr hierarchy)"""
    return _compile.Compile_WriteBoolSpecs(out, enc, hierarchy)

def Compile_is_expr_booleanizable(st: 'SymbTable_ptr const', expr: 'node_ptr', word_booleanizable: 'boolean', cache: 'hash_ptr') -> "boolean":
    """Compile_is_expr_booleanizable(SymbTable_ptr const st, node_ptr expr, boolean word_booleanizable, hash_ptr cache) -> boolean"""
    return _compile.Compile_is_expr_booleanizable(st, expr, word_booleanizable, cache)

def Compile_expr2bexpr(enc: 'BddEnc_ptr', det_layer: 'SymbLayer_ptr', expr: 'Expr_ptr') -> "Expr_ptr":
    """Compile_expr2bexpr(BddEnc_ptr enc, SymbLayer_ptr det_layer, Expr_ptr expr) -> Expr_ptr"""
    return _compile.Compile_expr2bexpr(enc, det_layer, expr)

def Compile_detexpr2bexpr(enc: 'BddEnc_ptr', expr: 'Expr_ptr') -> "Expr_ptr":
    """Compile_detexpr2bexpr(BddEnc_ptr enc, Expr_ptr expr) -> Expr_ptr"""
    return _compile.Compile_detexpr2bexpr(enc, expr)

def Compile_detexpr2bexpr_list(enc: 'BddEnc_ptr', expr: 'Expr_ptr') -> "Expr_ptr":
    """Compile_detexpr2bexpr_list(BddEnc_ptr enc, Expr_ptr expr) -> Expr_ptr"""
    return _compile.Compile_detexpr2bexpr_list(enc, expr)

def Compile_cleanup_booleanizer_cache_about(st: 'SymbTable_ptr', symbs: 'NodeList_ptr') -> "void":
    """Compile_cleanup_booleanizer_cache_about(SymbTable_ptr st, NodeList_ptr symbs)"""
    return _compile.Compile_cleanup_booleanizer_cache_about(st, symbs)

def Formula_GetDependencies(arg1: 'SymbTable_ptr const', arg2: 'node_ptr', arg3: 'node_ptr') -> "Set_t":
    """Formula_GetDependencies(SymbTable_ptr const arg1, node_ptr arg2, node_ptr arg3) -> Set_t"""
    return _compile.Formula_GetDependencies(arg1, arg2, arg3)

def Formula_GetDependenciesByType(arg1: 'SymbTable_ptr const', arg2: 'node_ptr', arg3: 'node_ptr', arg4: 'SymbFilterType', arg5: 'boolean') -> "Set_t":
    """Formula_GetDependenciesByType(SymbTable_ptr const arg1, node_ptr arg2, node_ptr arg3, SymbFilterType arg4, boolean arg5) -> Set_t"""
    return _compile.Formula_GetDependenciesByType(arg1, arg2, arg3, arg4, arg5)

def Formula_GetConstants(symb_table: 'SymbTable_ptr const', formula: 'node_ptr', context: 'node_ptr') -> "Set_t":
    """Formula_GetConstants(SymbTable_ptr const symb_table, node_ptr formula, node_ptr context) -> Set_t"""
    return _compile.Formula_GetConstants(symb_table, formula, context)

def Formulae_GetDependencies(arg1: 'SymbTable_ptr const', arg2: 'node_ptr', arg3: 'node_ptr', arg4: 'node_ptr') -> "Set_t":
    """Formulae_GetDependencies(SymbTable_ptr const arg1, node_ptr arg2, node_ptr arg3, node_ptr arg4) -> Set_t"""
    return _compile.Formulae_GetDependencies(arg1, arg2, arg3, arg4)

def ComputeCOIFixpoint(symb_table: 'SymbTable_ptr const', hierarchy: 'FlatHierarchy_ptr const', expression: 'Expr_ptr const', steps: 'int const', reached_fixpoint: 'boolean *') -> "Set_t":
    """ComputeCOIFixpoint(SymbTable_ptr const symb_table, FlatHierarchy_ptr const hierarchy, Expr_ptr const expression, int const steps, boolean * reached_fixpoint) -> Set_t"""
    return _compile.ComputeCOIFixpoint(symb_table, hierarchy, expression, steps, reached_fixpoint)

def ComputeCOI(arg1: 'SymbTable_ptr const', arg2: 'Set_t') -> "Set_t":
    """ComputeCOI(SymbTable_ptr const arg1, Set_t arg2) -> Set_t"""
    return _compile.ComputeCOI(arg1, arg2)

def set_definition_mode_to_get() -> "void":
    """set_definition_mode_to_get()"""
    return _compile.set_definition_mode_to_get()

def set_definition_mode_to_expand() -> "void":
    """set_definition_mode_to_expand()"""
    return _compile.set_definition_mode_to_expand()

def definition_mode_is_expand() -> "int":
    """definition_mode_is_expand() -> int"""
    return _compile.definition_mode_is_expand()

def Flatten_GetDefinition(symb_table: 'SymbTable_ptr const', atom: 'node_ptr') -> "node_ptr":
    """Flatten_GetDefinition(SymbTable_ptr const symb_table, node_ptr atom) -> node_ptr"""
    return _compile.Flatten_GetDefinition(symb_table, atom)

def Flatten_remove_symbol_info(name: 'node_ptr') -> "void":
    """Flatten_remove_symbol_info(node_ptr name)"""
    return _compile.Flatten_remove_symbol_info(name)

def Compile_get_global_symb_table() -> "SymbTable_ptr":
    """Compile_get_global_symb_table() -> SymbTable_ptr"""
    return _compile.Compile_get_global_symb_table()

def Compile_get_global_predicate_normaliser() -> "PredicateNormaliser_ptr":
    """Compile_get_global_predicate_normaliser() -> PredicateNormaliser_ptr"""
    return _compile.Compile_get_global_predicate_normaliser()

def CompileFlatten_normalise_value_list(old_value_list: 'node_ptr') -> "node_ptr":
    """CompileFlatten_normalise_value_list(node_ptr old_value_list) -> node_ptr"""
    return _compile.CompileFlatten_normalise_value_list(old_value_list)

def Compile_get_global_fsm_builder() -> "FsmBuilder_ptr":
    """Compile_get_global_fsm_builder() -> FsmBuilder_ptr"""
    return _compile.Compile_get_global_fsm_builder()

def Compile_pop_distrib_ops(prop: 'node_ptr') -> "node_ptr":
    """Compile_pop_distrib_ops(node_ptr prop) -> node_ptr"""
    return _compile.Compile_pop_distrib_ops(prop)

def Compile_make_sorted_vars_list_from_order(st: 'SymbTable_ptr const', vars: 'NodeList_ptr const', vars_order: 'NodeList_ptr const') -> "Set_t":
    """Compile_make_sorted_vars_list_from_order(SymbTable_ptr const st, NodeList_ptr const vars, NodeList_ptr const vars_order) -> Set_t"""
    return _compile.Compile_make_sorted_vars_list_from_order(st, vars, vars_order)

def Compile_check_if_flattening_was_built(err: 'FILE *') -> "int":
    """Compile_check_if_flattening_was_built(FILE * err) -> int"""
    return _compile.Compile_check_if_flattening_was_built(err)

def Compile_check_if_encoding_was_built(err: 'FILE *') -> "int":
    """Compile_check_if_encoding_was_built(FILE * err) -> int"""
    return _compile.Compile_check_if_encoding_was_built(err)

def Compile_check_if_flat_model_was_built(err: 'FILE *', forced: 'boolean') -> "int":
    """Compile_check_if_flat_model_was_built(FILE * err, boolean forced) -> int"""
    return _compile.Compile_check_if_flat_model_was_built(err, forced)

def Compile_check_if_bool_model_was_built(err: 'FILE *', forced: 'boolean') -> "int":
    """Compile_check_if_bool_model_was_built(FILE * err, boolean forced) -> int"""
    return _compile.Compile_check_if_bool_model_was_built(err, forced)

def Compile_check_if_model_was_built(err: 'FILE *', forced: 'boolean') -> "int":
    """Compile_check_if_model_was_built(FILE * err, boolean forced) -> int"""
    return _compile.Compile_check_if_model_was_built(err, forced)

def Compile_InstantiateType(st: 'SymbTable_ptr', layer: 'SymbLayer_ptr', name: 'node_ptr', type: 'node_ptr', context: 'node_ptr') -> "SymbType_ptr":
    """Compile_InstantiateType(SymbTable_ptr st, SymbLayer_ptr layer, node_ptr name, node_ptr type, node_ptr context) -> SymbType_ptr"""
    return _compile.Compile_InstantiateType(st, layer, name, type, context)

def Compile_DeclareVariable(symb_table: 'SymbTable_ptr', layer: 'SymbLayer_ptr', name: 'node_ptr', type: 'SymbType_ptr', context: 'node_ptr', mode: 'Instantiation_Variables_Mode_Type') -> "boolean":
    """Compile_DeclareVariable(SymbTable_ptr symb_table, SymbLayer_ptr layer, node_ptr name, SymbType_ptr type, node_ptr context, Instantiation_Variables_Mode_Type mode) -> boolean"""
    return _compile.Compile_DeclareVariable(symb_table, layer, name, type, context, mode)

def Compile_make_dag_info(expr: 'node_ptr', hash: 'hash_ptr') -> "node_ptr":
    """Compile_make_dag_info(node_ptr expr, hash_ptr hash) -> node_ptr"""
    return _compile.Compile_make_dag_info(expr, hash)

def Compile_convert_to_dag(symb_table: 'SymbTable_ptr', expr: 'node_ptr', hash: 'hash_ptr', defines: 'hash_ptr') -> "node_ptr":
    """Compile_convert_to_dag(SymbTable_ptr symb_table, node_ptr expr, hash_ptr hash, hash_ptr defines) -> node_ptr"""
    return _compile.Compile_convert_to_dag(symb_table, expr, hash, defines)

def Compile_write_dag_defines(out: 'FILE *', defines: 'hash_ptr') -> "void":
    """Compile_write_dag_defines(FILE * out, hash_ptr defines)"""
    return _compile.Compile_write_dag_defines(out, defines)

def Compile_destroy_dag_info(dag_info: 'hash_ptr', defines: 'hash_ptr') -> "void":
    """Compile_destroy_dag_info(hash_ptr dag_info, hash_ptr defines)"""
    return _compile.Compile_destroy_dag_info(dag_info, defines)

def Compile_print_array_define(out: 'FILE *', n: 'node_ptr const') -> "void":
    """Compile_print_array_define(FILE * out, node_ptr const n)"""
    return _compile.Compile_print_array_define(out, n)

def Compile_get_obfuscation_map(symb_table: 'SymbTable_ptr const') -> "hash_ptr":
    """Compile_get_obfuscation_map(SymbTable_ptr const symb_table) -> hash_ptr"""
    return _compile.Compile_get_obfuscation_map(symb_table)

def Compile_obfuscate_expression(symb_table: 'SymbTable_ptr const', expr: 'node_ptr', obfuscation_map: 'hash_ptr const') -> "node_ptr":
    """Compile_obfuscate_expression(SymbTable_ptr const symb_table, node_ptr expr, hash_ptr const obfuscation_map) -> node_ptr"""
    return _compile.Compile_obfuscate_expression(symb_table, expr, obfuscation_map)

def FlatHierarchy_create(st: 'SymbTable_ptr') -> "FlatHierarchy_ptr":
    """FlatHierarchy_create(SymbTable_ptr st) -> FlatHierarchy_ptr"""
    return _compile.FlatHierarchy_create(st)

def FlatHierarchy_create_from_members(st: 'SymbTable_ptr', init: 'node_ptr', invar: 'node_ptr', trans: 'node_ptr', input: 'node_ptr', justice: 'node_ptr', compassion: 'node_ptr') -> "FlatHierarchy_ptr":
    """FlatHierarchy_create_from_members(SymbTable_ptr st, node_ptr init, node_ptr invar, node_ptr trans, node_ptr input, node_ptr justice, node_ptr compassion) -> FlatHierarchy_ptr"""
    return _compile.FlatHierarchy_create_from_members(st, init, invar, trans, input, justice, compassion)

def FlatHierarchy_destroy(arg1: 'FlatHierarchy_ptr') -> "void":
    """FlatHierarchy_destroy(FlatHierarchy_ptr arg1)"""
    return _compile.FlatHierarchy_destroy(arg1)

def FlatHierarchy_copy(arg1: 'FlatHierarchy_ptr const') -> "FlatHierarchy_ptr":
    """FlatHierarchy_copy(FlatHierarchy_ptr const arg1) -> FlatHierarchy_ptr"""
    return _compile.FlatHierarchy_copy(arg1)

def FlatHierarchy_mergeinto(arg1: 'FlatHierarchy_ptr', other: 'FlatHierarchy_ptr const') -> "void":
    """FlatHierarchy_mergeinto(FlatHierarchy_ptr arg1, FlatHierarchy_ptr const other)"""
    return _compile.FlatHierarchy_mergeinto(arg1, other)

def FlatHierarchy_get_symb_table(arg1: 'FlatHierarchy_ptr const') -> "SymbTable_ptr":
    """FlatHierarchy_get_symb_table(FlatHierarchy_ptr const arg1) -> SymbTable_ptr"""
    return _compile.FlatHierarchy_get_symb_table(arg1)

def FlatHierarchy_get_init(cmp: 'FlatHierarchy_ptr') -> "node_ptr":
    """FlatHierarchy_get_init(FlatHierarchy_ptr cmp) -> node_ptr"""
    return _compile.FlatHierarchy_get_init(cmp)

def FlatHierarchy_set_init(cmp: 'FlatHierarchy_ptr', n: 'node_ptr') -> "void":
    """FlatHierarchy_set_init(FlatHierarchy_ptr cmp, node_ptr n)"""
    return _compile.FlatHierarchy_set_init(cmp, n)

def FlatHierarchy_get_invar(cmp: 'FlatHierarchy_ptr') -> "node_ptr":
    """FlatHierarchy_get_invar(FlatHierarchy_ptr cmp) -> node_ptr"""
    return _compile.FlatHierarchy_get_invar(cmp)

def FlatHierarchy_set_invar(cmp: 'FlatHierarchy_ptr', n: 'node_ptr') -> "void":
    """FlatHierarchy_set_invar(FlatHierarchy_ptr cmp, node_ptr n)"""
    return _compile.FlatHierarchy_set_invar(cmp, n)

def FlatHierarchy_get_trans(cmp: 'FlatHierarchy_ptr') -> "node_ptr":
    """FlatHierarchy_get_trans(FlatHierarchy_ptr cmp) -> node_ptr"""
    return _compile.FlatHierarchy_get_trans(cmp)

def FlatHierarchy_set_trans(cmp: 'FlatHierarchy_ptr', n: 'node_ptr') -> "void":
    """FlatHierarchy_set_trans(FlatHierarchy_ptr cmp, node_ptr n)"""
    return _compile.FlatHierarchy_set_trans(cmp, n)

def FlatHierarchy_get_input(cmp: 'FlatHierarchy_ptr') -> "node_ptr":
    """FlatHierarchy_get_input(FlatHierarchy_ptr cmp) -> node_ptr"""
    return _compile.FlatHierarchy_get_input(cmp)

def FlatHierarchy_set_input(cmp: 'FlatHierarchy_ptr', n: 'node_ptr') -> "void":
    """FlatHierarchy_set_input(FlatHierarchy_ptr cmp, node_ptr n)"""
    return _compile.FlatHierarchy_set_input(cmp, n)

def FlatHierarchy_get_assign(cmp: 'FlatHierarchy_ptr') -> "node_ptr":
    """FlatHierarchy_get_assign(FlatHierarchy_ptr cmp) -> node_ptr"""
    return _compile.FlatHierarchy_get_assign(cmp)

def FlatHierarchy_set_assign(cmp: 'FlatHierarchy_ptr', n: 'node_ptr') -> "void":
    """FlatHierarchy_set_assign(FlatHierarchy_ptr cmp, node_ptr n)"""
    return _compile.FlatHierarchy_set_assign(cmp, n)

def FlatHierarchy_get_justice(cmp: 'FlatHierarchy_ptr') -> "node_ptr":
    """FlatHierarchy_get_justice(FlatHierarchy_ptr cmp) -> node_ptr"""
    return _compile.FlatHierarchy_get_justice(cmp)

def FlatHierarchy_set_justice(cmp: 'FlatHierarchy_ptr', n: 'node_ptr') -> "void":
    """FlatHierarchy_set_justice(FlatHierarchy_ptr cmp, node_ptr n)"""
    return _compile.FlatHierarchy_set_justice(cmp, n)

def FlatHierarchy_get_compassion(cmp: 'FlatHierarchy_ptr') -> "node_ptr":
    """FlatHierarchy_get_compassion(FlatHierarchy_ptr cmp) -> node_ptr"""
    return _compile.FlatHierarchy_get_compassion(cmp)

def FlatHierarchy_set_compassion(cmp: 'FlatHierarchy_ptr', n: 'node_ptr') -> "void":
    """FlatHierarchy_set_compassion(FlatHierarchy_ptr cmp, node_ptr n)"""
    return _compile.FlatHierarchy_set_compassion(cmp, n)

def FlatHierarchy_add_property_name(cmp: 'FlatHierarchy_ptr', name: 'node_ptr') -> "boolean":
    """FlatHierarchy_add_property_name(FlatHierarchy_ptr cmp, node_ptr name) -> boolean"""
    return _compile.FlatHierarchy_add_property_name(cmp, name)

def FlatHierarchy_get_spec(cmp: 'FlatHierarchy_ptr') -> "node_ptr":
    """FlatHierarchy_get_spec(FlatHierarchy_ptr cmp) -> node_ptr"""
    return _compile.FlatHierarchy_get_spec(cmp)

def FlatHierarchy_set_spec(cmp: 'FlatHierarchy_ptr', n: 'node_ptr') -> "void":
    """FlatHierarchy_set_spec(FlatHierarchy_ptr cmp, node_ptr n)"""
    return _compile.FlatHierarchy_set_spec(cmp, n)

def FlatHierarchy_get_ltlspec(cmp: 'FlatHierarchy_ptr') -> "node_ptr":
    """FlatHierarchy_get_ltlspec(FlatHierarchy_ptr cmp) -> node_ptr"""
    return _compile.FlatHierarchy_get_ltlspec(cmp)

def FlatHierarchy_set_ltlspec(cmp: 'FlatHierarchy_ptr', n: 'node_ptr') -> "void":
    """FlatHierarchy_set_ltlspec(FlatHierarchy_ptr cmp, node_ptr n)"""
    return _compile.FlatHierarchy_set_ltlspec(cmp, n)

def FlatHierarchy_get_invarspec(cmp: 'FlatHierarchy_ptr') -> "node_ptr":
    """FlatHierarchy_get_invarspec(FlatHierarchy_ptr cmp) -> node_ptr"""
    return _compile.FlatHierarchy_get_invarspec(cmp)

def FlatHierarchy_set_invarspec(cmp: 'FlatHierarchy_ptr', n: 'node_ptr') -> "void":
    """FlatHierarchy_set_invarspec(FlatHierarchy_ptr cmp, node_ptr n)"""
    return _compile.FlatHierarchy_set_invarspec(cmp, n)

def FlatHierarchy_get_pslspec(cmp: 'FlatHierarchy_ptr') -> "node_ptr":
    """FlatHierarchy_get_pslspec(FlatHierarchy_ptr cmp) -> node_ptr"""
    return _compile.FlatHierarchy_get_pslspec(cmp)

def FlatHierarchy_set_pslspec(cmp: 'FlatHierarchy_ptr', n: 'node_ptr') -> "void":
    """FlatHierarchy_set_pslspec(FlatHierarchy_ptr cmp, node_ptr n)"""
    return _compile.FlatHierarchy_set_pslspec(cmp, n)

def FlatHierarchy_get_compute(cmp: 'FlatHierarchy_ptr') -> "node_ptr":
    """FlatHierarchy_get_compute(FlatHierarchy_ptr cmp) -> node_ptr"""
    return _compile.FlatHierarchy_get_compute(cmp)

def FlatHierarchy_set_compute(cmp: 'FlatHierarchy_ptr', n: 'node_ptr') -> "void":
    """FlatHierarchy_set_compute(FlatHierarchy_ptr cmp, node_ptr n)"""
    return _compile.FlatHierarchy_set_compute(cmp, n)

def FlatHierarchy_get_vars(cmp: 'FlatHierarchy_ptr') -> "Set_t":
    """FlatHierarchy_get_vars(FlatHierarchy_ptr cmp) -> Set_t"""
    return _compile.FlatHierarchy_get_vars(cmp)

def FlatHierarchy_add_var(cmp: 'FlatHierarchy_ptr', n: 'node_ptr') -> "void":
    """FlatHierarchy_add_var(FlatHierarchy_ptr cmp, node_ptr n)"""
    return _compile.FlatHierarchy_add_var(cmp, n)

def FlatHierarchy_remove_var(arg1: 'FlatHierarchy_ptr', n: 'node_ptr') -> "void":
    """FlatHierarchy_remove_var(FlatHierarchy_ptr arg1, node_ptr n)"""
    return _compile.FlatHierarchy_remove_var(arg1, n)

def FlatHierarchy_get_ordered_vars(arg1: 'FlatHierarchy_ptr const', outbound_edges: 'hash_ptr *') -> "NodeList_ptr":
    """FlatHierarchy_get_ordered_vars(FlatHierarchy_ptr const arg1, hash_ptr * outbound_edges) -> NodeList_ptr"""
    return _compile.FlatHierarchy_get_ordered_vars(arg1, outbound_edges)

def FlatHierarchy_get_preds(cmp: 'FlatHierarchy_ptr') -> "node_ptr":
    """FlatHierarchy_get_preds(FlatHierarchy_ptr cmp) -> node_ptr"""
    return _compile.FlatHierarchy_get_preds(cmp)

def FlatHierarchy_add_pred(cmp: 'FlatHierarchy_ptr', n: 'node_ptr') -> "void":
    """FlatHierarchy_add_pred(FlatHierarchy_ptr cmp, node_ptr n)"""
    return _compile.FlatHierarchy_add_pred(cmp, n)

def FlatHierarchy_set_pred(cmp: 'FlatHierarchy_ptr', n: 'node_ptr') -> "void":
    """FlatHierarchy_set_pred(FlatHierarchy_ptr cmp, node_ptr n)"""
    return _compile.FlatHierarchy_set_pred(cmp, n)

def FlatHierarchy_get_mirrors(cmp: 'FlatHierarchy_ptr') -> "node_ptr":
    """FlatHierarchy_get_mirrors(FlatHierarchy_ptr cmp) -> node_ptr"""
    return _compile.FlatHierarchy_get_mirrors(cmp)

def FlatHierarchy_add_mirror(cmp: 'FlatHierarchy_ptr', n: 'node_ptr') -> "void":
    """FlatHierarchy_add_mirror(FlatHierarchy_ptr cmp, node_ptr n)"""
    return _compile.FlatHierarchy_add_mirror(cmp, n)

def FlatHierarchy_set_mirror(cmp: 'FlatHierarchy_ptr', n: 'node_ptr') -> "void":
    """FlatHierarchy_set_mirror(FlatHierarchy_ptr cmp, node_ptr n)"""
    return _compile.FlatHierarchy_set_mirror(cmp, n)

def FlatHierarchy_self_check(arg1: 'FlatHierarchy_ptr const') -> "void":
    """FlatHierarchy_self_check(FlatHierarchy_ptr const arg1)"""
    return _compile.FlatHierarchy_self_check(arg1)

def FlatHierarchy_lookup_assign(arg1: 'FlatHierarchy_ptr', name: 'node_ptr') -> "node_ptr":
    """FlatHierarchy_lookup_assign(FlatHierarchy_ptr arg1, node_ptr name) -> node_ptr"""
    return _compile.FlatHierarchy_lookup_assign(arg1, name)

def FlatHierarchy_insert_assign(arg1: 'FlatHierarchy_ptr', name: 'node_ptr', assign: 'node_ptr') -> "void":
    """FlatHierarchy_insert_assign(FlatHierarchy_ptr arg1, node_ptr name, node_ptr assign)"""
    return _compile.FlatHierarchy_insert_assign(arg1, name, assign)

def FlatHierarchy_lookup_constrains(arg1: 'FlatHierarchy_ptr', name: 'node_ptr') -> "node_ptr":
    """FlatHierarchy_lookup_constrains(FlatHierarchy_ptr arg1, node_ptr name) -> node_ptr"""
    return _compile.FlatHierarchy_lookup_constrains(arg1, name)

def FlatHierarchy_add_constrains(arg1: 'FlatHierarchy_ptr', name: 'node_ptr', expr: 'node_ptr') -> "void":
    """FlatHierarchy_add_constrains(FlatHierarchy_ptr arg1, node_ptr name, node_ptr expr)"""
    return _compile.FlatHierarchy_add_constrains(arg1, name, expr)

def FlatHierarchy_lookup_constant_constrains(arg1: 'FlatHierarchy_ptr', type: 'int') -> "node_ptr":
    """FlatHierarchy_lookup_constant_constrains(FlatHierarchy_ptr arg1, int type) -> node_ptr"""
    return _compile.FlatHierarchy_lookup_constant_constrains(arg1, type)

def FlatHierarchy_add_constant_constrains(arg1: 'FlatHierarchy_ptr', expr: 'node_ptr', type: 'int') -> "void":
    """FlatHierarchy_add_constant_constrains(FlatHierarchy_ptr arg1, node_ptr expr, int type)"""
    return _compile.FlatHierarchy_add_constant_constrains(arg1, expr, type)

def FlatHierarchy_calculate_vars_constrains(arg1: 'FlatHierarchy_ptr') -> "void":
    """FlatHierarchy_calculate_vars_constrains(FlatHierarchy_ptr arg1)"""
    return _compile.FlatHierarchy_calculate_vars_constrains(arg1)

def FlatHierarchy_get_var_expr_associations(arg1: 'FlatHierarchy_ptr') -> "hash_ptr":
    """FlatHierarchy_get_var_expr_associations(FlatHierarchy_ptr arg1) -> hash_ptr"""
    return _compile.FlatHierarchy_get_var_expr_associations(arg1)

def FlatHierarchy_set_var_expr_associations(arg1: 'FlatHierarchy_ptr', h: 'hash_ptr') -> "void":
    """FlatHierarchy_set_var_expr_associations(FlatHierarchy_ptr arg1, hash_ptr h)"""
    return _compile.FlatHierarchy_set_var_expr_associations(arg1, h)

def FlatHierarchy_clear_var_expr_associations(arg1: 'FlatHierarchy_ptr') -> "void":
    """FlatHierarchy_clear_var_expr_associations(FlatHierarchy_ptr arg1)"""
    return _compile.FlatHierarchy_clear_var_expr_associations(arg1)

def FlatHierarchy_get_constants_associations(arg1: 'FlatHierarchy_ptr') -> "hash_ptr":
    """FlatHierarchy_get_constants_associations(FlatHierarchy_ptr arg1) -> hash_ptr"""
    return _compile.FlatHierarchy_get_constants_associations(arg1)

def FlatHierarchy_set_constants_associations(arg1: 'FlatHierarchy_ptr', h: 'hash_ptr') -> "void":
    """FlatHierarchy_set_constants_associations(FlatHierarchy_ptr arg1, hash_ptr h)"""
    return _compile.FlatHierarchy_set_constants_associations(arg1, h)

def FlatHierarchy_clear_constants_associations(arg1: 'FlatHierarchy_ptr') -> "void":
    """FlatHierarchy_clear_constants_associations(FlatHierarchy_ptr arg1)"""
    return _compile.FlatHierarchy_clear_constants_associations(arg1)

def FlatHierarchy_set_symb_table(arg1: 'FlatHierarchy_ptr const', symb_table: 'SymbTable_ptr') -> "void":
    """FlatHierarchy_set_symb_table(FlatHierarchy_ptr const arg1, SymbTable_ptr symb_table)"""
    return _compile.FlatHierarchy_set_symb_table(arg1, symb_table)

def PredicateExtractor_create(st: 'SymbTable_ptr', use_approx: 'boolean') -> "PredicateExtractor_ptr":
    """PredicateExtractor_create(SymbTable_ptr st, boolean use_approx) -> PredicateExtractor_ptr"""
    return _compile.PredicateExtractor_create(st, use_approx)

def PredicateExtractor_destroy(arg1: 'PredicateExtractor_ptr') -> "void":
    """PredicateExtractor_destroy(PredicateExtractor_ptr arg1)"""
    return _compile.PredicateExtractor_destroy(arg1)

def PredicateExtractor_compute_preds(arg1: 'PredicateExtractor_ptr', expr: 'node_ptr') -> "void":
    """PredicateExtractor_compute_preds(PredicateExtractor_ptr arg1, node_ptr expr)"""
    return _compile.PredicateExtractor_compute_preds(arg1, expr)

def PredicateExtractor_compute_preds_from_hierarchy(arg1: 'PredicateExtractor_ptr', fh: 'FlatHierarchy_ptr') -> "void":
    """PredicateExtractor_compute_preds_from_hierarchy(PredicateExtractor_ptr arg1, FlatHierarchy_ptr fh)"""
    return _compile.PredicateExtractor_compute_preds_from_hierarchy(arg1, fh)

def PredicateExtractor_get_all_preds(arg1: 'PredicateExtractor_ptr const') -> "Set_t":
    """PredicateExtractor_get_all_preds(PredicateExtractor_ptr const arg1) -> Set_t"""
    return _compile.PredicateExtractor_get_all_preds(arg1)

def PredicateExtractor_get_all_clusters(arg1: 'PredicateExtractor_ptr const') -> "Set_t":
    """PredicateExtractor_get_all_clusters(PredicateExtractor_ptr const arg1) -> Set_t"""
    return _compile.PredicateExtractor_get_all_clusters(arg1)

def PredicateExtractor_get_var_cluster(arg1: 'PredicateExtractor_ptr const', var: 'node_ptr') -> "Set_t":
    """PredicateExtractor_get_var_cluster(PredicateExtractor_ptr const arg1, node_ptr var) -> Set_t"""
    return _compile.PredicateExtractor_get_var_cluster(arg1, var)

def PredicateExtractor_get_preds_of_a_cluster(arg1: 'PredicateExtractor_ptr const', cluster: 'Set_t') -> "Set_t":
    """PredicateExtractor_get_preds_of_a_cluster(PredicateExtractor_ptr const arg1, Set_t cluster) -> Set_t"""
    return _compile.PredicateExtractor_get_preds_of_a_cluster(arg1, cluster)

def PredicateExtractor_print(arg1: 'PredicateExtractor_ptr const', stream: 'FILE *', printPredicates: 'boolean', printClusters: 'boolean') -> "void":
    """PredicateExtractor_print(PredicateExtractor_ptr const arg1, FILE * stream, boolean printPredicates, boolean printClusters)"""
    return _compile.PredicateExtractor_print(arg1, stream, printPredicates, printClusters)

def PredicateNormaliser_create(st: 'SymbTable_ptr') -> "PredicateNormaliser_ptr":
    """PredicateNormaliser_create(SymbTable_ptr st) -> PredicateNormaliser_ptr"""
    return _compile.PredicateNormaliser_create(st)

def PredicateNormaliser_destroy(arg1: 'PredicateNormaliser_ptr') -> "void":
    """PredicateNormaliser_destroy(PredicateNormaliser_ptr arg1)"""
    return _compile.PredicateNormaliser_destroy(arg1)

def PredicateNormaliser_normalise_expr(arg1: 'PredicateNormaliser_ptr', expr: 'node_ptr') -> "node_ptr":
    """PredicateNormaliser_normalise_expr(PredicateNormaliser_ptr arg1, node_ptr expr) -> node_ptr"""
    return _compile.PredicateNormaliser_normalise_expr(arg1, expr)

def PredicateNormaliser_normalise_specification(arg1: 'PredicateNormaliser_ptr', expr: 'node_ptr') -> "node_ptr":
    """PredicateNormaliser_normalise_specification(PredicateNormaliser_ptr arg1, node_ptr expr) -> node_ptr"""
    return _compile.PredicateNormaliser_normalise_specification(arg1, expr)

def PredicateNormaliser_get_predicates_only(arg1: 'PredicateNormaliser_ptr const', preds: 'Set_t *', expr: 'node_ptr') -> "void":
    """PredicateNormaliser_get_predicates_only(PredicateNormaliser_ptr const arg1, Set_t * preds, node_ptr expr)"""
    return _compile.PredicateNormaliser_get_predicates_only(arg1, preds, expr)

def PredicateNormaliser_print_predicates_only(arg1: 'PredicateNormaliser_ptr const', stream: 'FILE *', expr: 'node_ptr') -> "void":
    """PredicateNormaliser_print_predicates_only(PredicateNormaliser_ptr const arg1, FILE * stream, node_ptr expr)"""
    return _compile.PredicateNormaliser_print_predicates_only(arg1, stream, expr)

def compile_flatten_smv(calc_vars_constrains: 'boolean') -> "int":
    """compile_flatten_smv(boolean calc_vars_constrains) -> int"""
    return _compile.compile_flatten_smv(calc_vars_constrains)

def flatten_hierarchy() -> "int":
    """flatten_hierarchy() -> int"""
    return _compile.flatten_hierarchy()

def Compile_ConstructHierarchy(symb_table: 'SymbTable_ptr', arg2: 'SymbLayer_ptr', arg3: 'node_ptr', arg4: 'node_ptr', arg5: 'node_ptr', arg6: 'FlatHierarchy_ptr', arg7: 'HrcNode_ptr', arg8: 'hash_ptr') -> "void":
    """Compile_ConstructHierarchy(SymbTable_ptr symb_table, SymbLayer_ptr arg2, node_ptr arg3, node_ptr arg4, node_ptr arg5, FlatHierarchy_ptr arg6, HrcNode_ptr arg7, hash_ptr arg8)"""
    return _compile.Compile_ConstructHierarchy(symb_table, arg2, arg3, arg4, arg5, arg6, arg7, arg8)

def Compile_ProcessHierarchy(symb_table: 'SymbTable_ptr', layer: 'SymbLayer_ptr', hierachy: 'FlatHierarchy_ptr', name: 'node_ptr', create_process_variables: 'boolean', calc_vars_constr: 'boolean') -> "void":
    """Compile_ProcessHierarchy(SymbTable_ptr symb_table, SymbLayer_ptr layer, FlatHierarchy_ptr hierachy, node_ptr name, boolean create_process_variables, boolean calc_vars_constr)"""
    return _compile.Compile_ProcessHierarchy(symb_table, layer, hierachy, name, create_process_variables, calc_vars_constr)
class cmp_struct(_object):
    """Proxy of C cmp_struct struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, cmp_struct, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, cmp_struct, name)
    __repr__ = _swig_repr
    __swig_setmethods__["read_model"] = _compile.cmp_struct_read_model_set
    __swig_getmethods__["read_model"] = _compile.cmp_struct_read_model_get
    if _newclass:
        read_model = _swig_property(_compile.cmp_struct_read_model_get, _compile.cmp_struct_read_model_set)
    __swig_setmethods__["hrc_built"] = _compile.cmp_struct_hrc_built_set
    __swig_getmethods__["hrc_built"] = _compile.cmp_struct_hrc_built_get
    if _newclass:
        hrc_built = _swig_property(_compile.cmp_struct_hrc_built_get, _compile.cmp_struct_hrc_built_set)
    __swig_setmethods__["flatten_hierarchy"] = _compile.cmp_struct_flatten_hierarchy_set
    __swig_getmethods__["flatten_hierarchy"] = _compile.cmp_struct_flatten_hierarchy_get
    if _newclass:
        flatten_hierarchy = _swig_property(_compile.cmp_struct_flatten_hierarchy_get, _compile.cmp_struct_flatten_hierarchy_set)
    __swig_setmethods__["encode_variables"] = _compile.cmp_struct_encode_variables_set
    __swig_getmethods__["encode_variables"] = _compile.cmp_struct_encode_variables_get
    if _newclass:
        encode_variables = _swig_property(_compile.cmp_struct_encode_variables_get, _compile.cmp_struct_encode_variables_set)
    __swig_setmethods__["process_selector"] = _compile.cmp_struct_process_selector_set
    __swig_getmethods__["process_selector"] = _compile.cmp_struct_process_selector_get
    if _newclass:
        process_selector = _swig_property(_compile.cmp_struct_process_selector_get, _compile.cmp_struct_process_selector_set)
    __swig_setmethods__["build_frames"] = _compile.cmp_struct_build_frames_set
    __swig_getmethods__["build_frames"] = _compile.cmp_struct_build_frames_get
    if _newclass:
        build_frames = _swig_property(_compile.cmp_struct_build_frames_get, _compile.cmp_struct_build_frames_set)
    __swig_setmethods__["build_model"] = _compile.cmp_struct_build_model_set
    __swig_getmethods__["build_model"] = _compile.cmp_struct_build_model_get
    if _newclass:
        build_model = _swig_property(_compile.cmp_struct_build_model_get, _compile.cmp_struct_build_model_set)
    __swig_setmethods__["build_flat_model"] = _compile.cmp_struct_build_flat_model_set
    __swig_getmethods__["build_flat_model"] = _compile.cmp_struct_build_flat_model_get
    if _newclass:
        build_flat_model = _swig_property(_compile.cmp_struct_build_flat_model_get, _compile.cmp_struct_build_flat_model_set)
    __swig_setmethods__["build_bool_model"] = _compile.cmp_struct_build_bool_model_set
    __swig_getmethods__["build_bool_model"] = _compile.cmp_struct_build_bool_model_get
    if _newclass:
        build_bool_model = _swig_property(_compile.cmp_struct_build_bool_model_get, _compile.cmp_struct_build_bool_model_set)
    __swig_setmethods__["bmc_init"] = _compile.cmp_struct_bmc_init_set
    __swig_getmethods__["bmc_init"] = _compile.cmp_struct_bmc_init_get
    if _newclass:
        bmc_init = _swig_property(_compile.cmp_struct_bmc_init_get, _compile.cmp_struct_bmc_init_set)
    __swig_setmethods__["bmc_setup"] = _compile.cmp_struct_bmc_setup_set
    __swig_getmethods__["bmc_setup"] = _compile.cmp_struct_bmc_setup_get
    if _newclass:
        bmc_setup = _swig_property(_compile.cmp_struct_bmc_setup_get, _compile.cmp_struct_bmc_setup_set)
    __swig_setmethods__["fairness_constraints"] = _compile.cmp_struct_fairness_constraints_set
    __swig_getmethods__["fairness_constraints"] = _compile.cmp_struct_fairness_constraints_get
    if _newclass:
        fairness_constraints = _swig_property(_compile.cmp_struct_fairness_constraints_get, _compile.cmp_struct_fairness_constraints_set)
    __swig_setmethods__["coi"] = _compile.cmp_struct_coi_set
    __swig_getmethods__["coi"] = _compile.cmp_struct_coi_get
    if _newclass:
        coi = _swig_property(_compile.cmp_struct_coi_get, _compile.cmp_struct_coi_set)

    def __init__(self):
        """__init__(cmp_struct self) -> cmp_struct"""
        this = _compile.new_cmp_struct()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _compile.delete_cmp_struct
    __del__ = lambda self: None
cmp_struct_swigregister = _compile.cmp_struct_swigregister
cmp_struct_swigregister(cmp_struct)
cvar = _compile.cvar


def cmp_struct_reset(cmp: 'cmp_struct') -> "void":
    """cmp_struct_reset(cmp_struct cmp)"""
    return _compile.cmp_struct_reset(cmp)

def FlattenSexp(symb_table: 'SymbTable_ptr const', sexp: 'node_ptr', context: 'node_ptr') -> "int *":
    """FlattenSexp(SymbTable_ptr const symb_table, node_ptr sexp, node_ptr context) -> node_ptr"""
    return _compile.FlattenSexp(symb_table, sexp, context)
# This file is compatible with both classic and new-style classes.


