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

def Bmc_SBMCGenSolveLtl(ltlprop: 'Prop_ptr', k: 'int const', relative_loop: 'int const', must_inc_length: 'boolean const', must_solve: 'boolean const', dump_type: 'Bmc_DumpType const', dump_fname_template: 'char const *') -> "int":
    """Bmc_SBMCGenSolveLtl(Prop_ptr ltlprop, int const k, int const relative_loop, boolean const must_inc_length, boolean const must_solve, Bmc_DumpType const dump_type, char const * dump_fname_template) -> int"""
    return _sbmc.Bmc_SBMCGenSolveLtl(ltlprop, k, relative_loop, must_inc_length, must_solve, dump_type, dump_fname_template)

def Sbmc_zigzag_incr(ltlprop: 'Prop_ptr', max_k: 'int const', opt_do_virtual_unrolling: 'int const', opt_do_completeness_check: 'int const') -> "int":
    """Sbmc_zigzag_incr(Prop_ptr ltlprop, int const max_k, int const opt_do_virtual_unrolling, int const opt_do_completeness_check) -> int"""
    return _sbmc.Sbmc_zigzag_incr(ltlprop, max_k, opt_do_virtual_unrolling, opt_do_completeness_check)

def Sbmc_zigzag_incr_assume(ltlprop: 'Prop_ptr', max_k: 'int const', opt_do_virtual_unrolling: 'int const', opt_do_completeness_check: 'int const', assumptions: 'Slist_ptr', conflict: 'Slist_ptr *') -> "int":
    """Sbmc_zigzag_incr_assume(Prop_ptr ltlprop, int const max_k, int const opt_do_virtual_unrolling, int const opt_do_completeness_check, Slist_ptr assumptions, Slist_ptr * conflict) -> int"""
    return _sbmc.Sbmc_zigzag_incr_assume(ltlprop, max_k, opt_do_virtual_unrolling, opt_do_completeness_check, assumptions, conflict)

def Sbmc_CommandCheckLtlSpecSBmc(argc: 'int', argv: 'char **') -> "int":
    """Sbmc_CommandCheckLtlSpecSBmc(int argc, char ** argv) -> int"""
    return _sbmc.Sbmc_CommandCheckLtlSpecSBmc(argc, argv)

def Sbmc_CommandGenLtlSpecSBmc(argc: 'int', argv: 'char **') -> "int":
    """Sbmc_CommandGenLtlSpecSBmc(int argc, char ** argv) -> int"""
    return _sbmc.Sbmc_CommandGenLtlSpecSBmc(argc, argv)

def Sbmc_CommandLTLCheckZigzagInc(argc: 'int', argv: 'char **') -> "int":
    """Sbmc_CommandLTLCheckZigzagInc(int argc, char ** argv) -> int"""
    return _sbmc.Sbmc_CommandLTLCheckZigzagInc(argc, argv)

def Sbmc_check_psl_property(prop: 'Prop_ptr', dump_prob: 'boolean', inc_sat: 'boolean', do_completeness_check: 'boolean', do_virtual_unrolling: 'boolean', single_prob: 'boolean', k: 'int', rel_loop: 'int') -> "int":
    """Sbmc_check_psl_property(Prop_ptr prop, boolean dump_prob, boolean inc_sat, boolean do_completeness_check, boolean do_virtual_unrolling, boolean single_prob, int k, int rel_loop) -> int"""
    return _sbmc.Sbmc_check_psl_property(prop, dump_prob, inc_sat, do_completeness_check, do_virtual_unrolling, single_prob, k, rel_loop)

def Bmc_Gen_SBMCProblem(be_fsm: 'BeFsm_ptr const', ltl_wff: 'node_ptr const', k: 'int const', l: 'int const') -> "be_ptr":
    """Bmc_Gen_SBMCProblem(BeFsm_ptr const be_fsm, node_ptr const ltl_wff, int const k, int const l) -> be_ptr"""
    return _sbmc.Bmc_Gen_SBMCProblem(be_fsm, ltl_wff, k, l)
BMC_HASH_NOTFOUND = _sbmc.BMC_HASH_NOTFOUND
class table_pair(_object):
    """Proxy of C table_pair struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, table_pair, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, table_pair, name)
    __repr__ = _swig_repr
    __swig_setmethods__["key"] = _sbmc.table_pair_key_set
    __swig_getmethods__["key"] = _sbmc.table_pair_key_get
    if _newclass:
        key = _swig_property(_sbmc.table_pair_key_get, _sbmc.table_pair_key_set)
    __swig_setmethods__["data"] = _sbmc.table_pair_data_set
    __swig_getmethods__["data"] = _sbmc.table_pair_data_get
    if _newclass:
        data = _swig_property(_sbmc.table_pair_data_get, _sbmc.table_pair_data_set)

    def __init__(self):
        """__init__(table_pair self) -> table_pair"""
        this = _sbmc.new_table_pair()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _sbmc.delete_table_pair
    __del__ = lambda self: None
table_pair_swigregister = _sbmc.table_pair_swigregister
table_pair_swigregister(table_pair)

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

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, htable, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, htable, name)
    __repr__ = _swig_repr
    __swig_setmethods__["alloc"] = _sbmc.htable_alloc_set
    __swig_getmethods__["alloc"] = _sbmc.htable_alloc_get
    if _newclass:
        alloc = _swig_property(_sbmc.htable_alloc_get, _sbmc.htable_alloc_set)
    __swig_setmethods__["occupied"] = _sbmc.htable_occupied_set
    __swig_getmethods__["occupied"] = _sbmc.htable_occupied_get
    if _newclass:
        occupied = _swig_property(_sbmc.htable_occupied_get, _sbmc.htable_occupied_set)
    __swig_setmethods__["table"] = _sbmc.htable_table_set
    __swig_getmethods__["table"] = _sbmc.htable_table_get
    if _newclass:
        table = _swig_property(_sbmc.htable_table_get, _sbmc.htable_table_set)

    def __init__(self):
        """__init__(htable self) -> htable"""
        this = _sbmc.new_htable()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _sbmc.delete_htable
    __del__ = lambda self: None
htable_swigregister = _sbmc.htable_swigregister
htable_swigregister(htable)


def Bmc_Hash_new_htable() -> "hashPtr":
    """Bmc_Hash_new_htable() -> htable"""
    return _sbmc.Bmc_Hash_new_htable()

def Bmc_Hash_find(arg1: 'htable', arg2: 'node_ptr') -> "int":
    """Bmc_Hash_find(htable arg1, node_ptr arg2) -> int"""
    return _sbmc.Bmc_Hash_find(arg1, arg2)

def Bmc_Hash_insert(arg1: 'htable', arg2: 'node_ptr', arg3: 'int') -> "void":
    """Bmc_Hash_insert(htable arg1, node_ptr arg2, int arg3)"""
    return _sbmc.Bmc_Hash_insert(arg1, arg2, arg3)

def Bmc_Hash_delete_table(hash: 'htable') -> "void":
    """Bmc_Hash_delete_table(htable hash)"""
    return _sbmc.Bmc_Hash_delete_table(hash)

def Bmc_Hash_size(hash: 'htable') -> "unsigned int":
    """Bmc_Hash_size(htable hash) -> unsigned int"""
    return _sbmc.Bmc_Hash_size(hash)
class nodeStack(_object):
    """Proxy of C nodeStack struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, nodeStack, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, nodeStack, name)
    __repr__ = _swig_repr
    __swig_setmethods__["alloc"] = _sbmc.nodeStack_alloc_set
    __swig_getmethods__["alloc"] = _sbmc.nodeStack_alloc_get
    if _newclass:
        alloc = _swig_property(_sbmc.nodeStack_alloc_get, _sbmc.nodeStack_alloc_set)
    __swig_setmethods__["first_free"] = _sbmc.nodeStack_first_free_set
    __swig_getmethods__["first_free"] = _sbmc.nodeStack_first_free_get
    if _newclass:
        first_free = _swig_property(_sbmc.nodeStack_first_free_get, _sbmc.nodeStack_first_free_set)
    __swig_setmethods__["table"] = _sbmc.nodeStack_table_set
    __swig_getmethods__["table"] = _sbmc.nodeStack_table_get
    if _newclass:
        table = _swig_property(_sbmc.nodeStack_table_get, _sbmc.nodeStack_table_set)

    def __init__(self):
        """__init__(nodeStack self) -> nodeStack"""
        this = _sbmc.new_nodeStack()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _sbmc.delete_nodeStack
    __del__ = lambda self: None
nodeStack_swigregister = _sbmc.nodeStack_swigregister
nodeStack_swigregister(nodeStack)


def Bmc_Stack_new_stack() -> "Bmc_Stack_ptr":
    """Bmc_Stack_new_stack() -> nodeStack"""
    return _sbmc.Bmc_Stack_new_stack()

def Bmc_Stack_push(arg1: 'nodeStack', arg2: 'node_ptr') -> "void":
    """Bmc_Stack_push(nodeStack arg1, node_ptr arg2)"""
    return _sbmc.Bmc_Stack_push(arg1, arg2)

def Bmc_Stack_pop(arg1: 'nodeStack') -> "node_ptr":
    """Bmc_Stack_pop(nodeStack arg1) -> node_ptr"""
    return _sbmc.Bmc_Stack_pop(arg1)

def Bmc_Stack_delete(stack: 'nodeStack') -> "void":
    """Bmc_Stack_delete(nodeStack stack)"""
    return _sbmc.Bmc_Stack_delete(stack)

def Bmc_Stack_size(stack: 'nodeStack') -> "unsigned int":
    """Bmc_Stack_size(nodeStack stack) -> unsigned int"""
    return _sbmc.Bmc_Stack_size(stack)

def Bmc_Stack_top(stack: 'nodeStack') -> "node_ptr":
    """Bmc_Stack_top(nodeStack stack) -> node_ptr"""
    return _sbmc.Bmc_Stack_top(stack)

def SBmc_Init() -> "void":
    """SBmc_Init()"""
    return _sbmc.SBmc_Init()

def SBmc_Quit() -> "void":
    """SBmc_Quit()"""
    return _sbmc.SBmc_Quit()

def SBmc_AddCmd() -> "void":
    """SBmc_AddCmd()"""
    return _sbmc.SBmc_AddCmd()

def sbmc_state_vars_create() -> "state_vars_struct *":
    """sbmc_state_vars_create() -> state_vars_struct *"""
    return _sbmc.sbmc_state_vars_create()

def sbmc_state_vars_destroy(svs: 'state_vars_struct *') -> "void":
    """sbmc_state_vars_destroy(state_vars_struct * svs)"""
    return _sbmc.sbmc_state_vars_destroy(svs)

def sbmc_state_vars_get_trans_state_vars(ss: 'state_vars_struct const *') -> "lsList":
    """sbmc_state_vars_get_trans_state_vars(state_vars_struct const * ss) -> lsList"""
    return _sbmc.sbmc_state_vars_get_trans_state_vars(ss)

def sbmc_state_vars_get_l_var(ss: 'state_vars_struct const *') -> "node_ptr":
    """sbmc_state_vars_get_l_var(state_vars_struct const * ss) -> node_ptr"""
    return _sbmc.sbmc_state_vars_get_l_var(ss)

def sbmc_state_vars_get_LoopExists_var(ss: 'state_vars_struct const *') -> "node_ptr":
    """sbmc_state_vars_get_LoopExists_var(state_vars_struct const * ss) -> node_ptr"""
    return _sbmc.sbmc_state_vars_get_LoopExists_var(ss)

def sbmc_state_vars_get_LastState_var(ss: 'state_vars_struct const *') -> "node_ptr":
    """sbmc_state_vars_get_LastState_var(state_vars_struct const * ss) -> node_ptr"""
    return _sbmc.sbmc_state_vars_get_LastState_var(ss)

def sbmc_state_vars_get_translation_vars_pd0(ss: 'state_vars_struct const *') -> "lsList":
    """sbmc_state_vars_get_translation_vars_pd0(state_vars_struct const * ss) -> lsList"""
    return _sbmc.sbmc_state_vars_get_translation_vars_pd0(ss)

def sbmc_state_vars_get_translation_vars_pdx(ss: 'state_vars_struct const *') -> "lsList":
    """sbmc_state_vars_get_translation_vars_pdx(state_vars_struct const * ss) -> lsList"""
    return _sbmc.sbmc_state_vars_get_translation_vars_pdx(ss)

def sbmc_state_vars_get_translation_vars_aux(ss: 'state_vars_struct const *') -> "lsList":
    """sbmc_state_vars_get_translation_vars_aux(state_vars_struct const * ss) -> lsList"""
    return _sbmc.sbmc_state_vars_get_translation_vars_aux(ss)

def sbmc_state_vars_get_formula_state_vars(ss: 'state_vars_struct const *') -> "lsList":
    """sbmc_state_vars_get_formula_state_vars(state_vars_struct const * ss) -> lsList"""
    return _sbmc.sbmc_state_vars_get_formula_state_vars(ss)

def sbmc_state_vars_get_formula_input_vars(ss: 'state_vars_struct const *') -> "lsList":
    """sbmc_state_vars_get_formula_input_vars(state_vars_struct const * ss) -> lsList"""
    return _sbmc.sbmc_state_vars_get_formula_input_vars(ss)

def sbmc_state_vars_get_simple_path_system_vars(ss: 'state_vars_struct const *') -> "lsList":
    """sbmc_state_vars_get_simple_path_system_vars(state_vars_struct const * ss) -> lsList"""
    return _sbmc.sbmc_state_vars_get_simple_path_system_vars(ss)

def sbmc_state_vars_set_trans_state_vars(ss: 'state_vars_struct *', f: 'lsList') -> "void":
    """sbmc_state_vars_set_trans_state_vars(state_vars_struct * ss, lsList f)"""
    return _sbmc.sbmc_state_vars_set_trans_state_vars(ss, f)

def sbmc_state_vars_set_l_var(ss: 'state_vars_struct *', f: 'node_ptr') -> "void":
    """sbmc_state_vars_set_l_var(state_vars_struct * ss, node_ptr f)"""
    return _sbmc.sbmc_state_vars_set_l_var(ss, f)

def sbmc_state_vars_set_LoopExists_var(ss: 'state_vars_struct *', f: 'node_ptr') -> "void":
    """sbmc_state_vars_set_LoopExists_var(state_vars_struct * ss, node_ptr f)"""
    return _sbmc.sbmc_state_vars_set_LoopExists_var(ss, f)

def sbmc_state_vars_set_LastState_var(ss: 'state_vars_struct *', f: 'node_ptr') -> "void":
    """sbmc_state_vars_set_LastState_var(state_vars_struct * ss, node_ptr f)"""
    return _sbmc.sbmc_state_vars_set_LastState_var(ss, f)

def sbmc_state_vars_set_translation_vars_pd0(ss: 'state_vars_struct *', f: 'lsList') -> "void":
    """sbmc_state_vars_set_translation_vars_pd0(state_vars_struct * ss, lsList f)"""
    return _sbmc.sbmc_state_vars_set_translation_vars_pd0(ss, f)

def sbmc_state_vars_set_translation_vars_pdx(ss: 'state_vars_struct *', f: 'lsList') -> "void":
    """sbmc_state_vars_set_translation_vars_pdx(state_vars_struct * ss, lsList f)"""
    return _sbmc.sbmc_state_vars_set_translation_vars_pdx(ss, f)

def sbmc_state_vars_set_translation_vars_aux(ss: 'state_vars_struct *', f: 'lsList') -> "void":
    """sbmc_state_vars_set_translation_vars_aux(state_vars_struct * ss, lsList f)"""
    return _sbmc.sbmc_state_vars_set_translation_vars_aux(ss, f)

def sbmc_state_vars_set_formula_state_vars(ss: 'state_vars_struct *', f: 'lsList') -> "void":
    """sbmc_state_vars_set_formula_state_vars(state_vars_struct * ss, lsList f)"""
    return _sbmc.sbmc_state_vars_set_formula_state_vars(ss, f)

def sbmc_state_vars_set_formula_input_vars(ss: 'state_vars_struct *', f: 'lsList') -> "void":
    """sbmc_state_vars_set_formula_input_vars(state_vars_struct * ss, lsList f)"""
    return _sbmc.sbmc_state_vars_set_formula_input_vars(ss, f)

def sbmc_state_vars_set_simple_path_system_vars(ss: 'state_vars_struct *', f: 'lsList') -> "void":
    """sbmc_state_vars_set_simple_path_system_vars(state_vars_struct * ss, lsList f)"""
    return _sbmc.sbmc_state_vars_set_simple_path_system_vars(ss, f)

def sbmc_state_vars_print(svs: 'state_vars_struct *', out: 'FILE *') -> "void":
    """sbmc_state_vars_print(state_vars_struct * svs, FILE * out)"""
    return _sbmc.sbmc_state_vars_print(svs, out)

def sbmc_set_create() -> "hash_ptr":
    """sbmc_set_create() -> hash_ptr"""
    return _sbmc.sbmc_set_create()

def sbmc_set_destroy(hash: 'hash_ptr') -> "void":
    """sbmc_set_destroy(hash_ptr hash)"""
    return _sbmc.sbmc_set_destroy(hash)

def sbmc_set_insert(hash: 'hash_ptr', bexp: 'node_ptr') -> "void":
    """sbmc_set_insert(hash_ptr hash, node_ptr bexp)"""
    return _sbmc.sbmc_set_insert(hash, bexp)

def sbmc_set_is_in(hash: 'hash_ptr', bexp: 'node_ptr') -> "int":
    """sbmc_set_is_in(hash_ptr hash, node_ptr bexp) -> int"""
    return _sbmc.sbmc_set_is_in(hash, bexp)

def sbmc_alloc_node_info() -> "sbmc_node_info *":
    """sbmc_alloc_node_info() -> sbmc_node_info *"""
    return _sbmc.sbmc_alloc_node_info()

def sbmc_node_info_free(info: 'sbmc_node_info *') -> "void":
    """sbmc_node_info_free(sbmc_node_info * info)"""
    return _sbmc.sbmc_node_info_free(info)

def sbmc_node_info_get_past_depth(h: 'sbmc_node_info *') -> "unsigned int":
    """sbmc_node_info_get_past_depth(sbmc_node_info * h) -> unsigned int"""
    return _sbmc.sbmc_node_info_get_past_depth(h)

def sbmc_node_info_get_trans_vars(h: 'sbmc_node_info *') -> "array_t *":
    """sbmc_node_info_get_trans_vars(sbmc_node_info * h) -> array_t *"""
    return _sbmc.sbmc_node_info_get_trans_vars(h)

def sbmc_node_info_get_trans_bes(h: 'sbmc_node_info *') -> "array_t *":
    """sbmc_node_info_get_trans_bes(sbmc_node_info * h) -> array_t *"""
    return _sbmc.sbmc_node_info_get_trans_bes(h)

def sbmc_node_info_get_aux_F_node(h: 'sbmc_node_info *') -> "node_ptr":
    """sbmc_node_info_get_aux_F_node(sbmc_node_info * h) -> node_ptr"""
    return _sbmc.sbmc_node_info_get_aux_F_node(h)

def sbmc_node_info_get_aux_F_trans(h: 'sbmc_node_info *') -> "array_t *":
    """sbmc_node_info_get_aux_F_trans(sbmc_node_info * h) -> array_t *"""
    return _sbmc.sbmc_node_info_get_aux_F_trans(h)

def sbmc_node_info_get_aux_G_node(h: 'sbmc_node_info *') -> "node_ptr":
    """sbmc_node_info_get_aux_G_node(sbmc_node_info * h) -> node_ptr"""
    return _sbmc.sbmc_node_info_get_aux_G_node(h)

def sbmc_node_info_get_aux_G_trans(h: 'sbmc_node_info *') -> "array_t *":
    """sbmc_node_info_get_aux_G_trans(sbmc_node_info * h) -> array_t *"""
    return _sbmc.sbmc_node_info_get_aux_G_trans(h)

def sbmc_node_info_set_past_depth(h: 'sbmc_node_info *', s: 'unsigned int') -> "void":
    """sbmc_node_info_set_past_depth(sbmc_node_info * h, unsigned int s)"""
    return _sbmc.sbmc_node_info_set_past_depth(h, s)

def sbmc_node_info_set_past_trans_vars(h: 'sbmc_node_info *', s: 'array_t *') -> "void":
    """sbmc_node_info_set_past_trans_vars(sbmc_node_info * h, array_t * s)"""
    return _sbmc.sbmc_node_info_set_past_trans_vars(h, s)

def sbmc_node_info_set_trans_bes(h: 'sbmc_node_info *', s: 'array_t *') -> "void":
    """sbmc_node_info_set_trans_bes(sbmc_node_info * h, array_t * s)"""
    return _sbmc.sbmc_node_info_set_trans_bes(h, s)

def sbmc_node_info_set_aux_F_node(h: 'sbmc_node_info *', s: 'node_ptr') -> "void":
    """sbmc_node_info_set_aux_F_node(sbmc_node_info * h, node_ptr s)"""
    return _sbmc.sbmc_node_info_set_aux_F_node(h, s)

def sbmc_node_info_set_aux_F_trans(h: 'sbmc_node_info *', s: 'array_t *') -> "void":
    """sbmc_node_info_set_aux_F_trans(sbmc_node_info * h, array_t * s)"""
    return _sbmc.sbmc_node_info_set_aux_F_trans(h, s)

def sbmc_node_info_set_aux_G_node(h: 'sbmc_node_info *', s: 'node_ptr') -> "void":
    """sbmc_node_info_set_aux_G_node(sbmc_node_info * h, node_ptr s)"""
    return _sbmc.sbmc_node_info_set_aux_G_node(h, s)

def sbmc_node_info_set_aux_G_trans(h: 'sbmc_node_info *', s: 'array_t *') -> "void":
    """sbmc_node_info_set_aux_G_trans(sbmc_node_info * h, array_t * s)"""
    return _sbmc.sbmc_node_info_set_aux_G_trans(h, s)

def sbmc_node_info_assoc_find(a: 'hash_ptr', n: 'node_ptr') -> "sbmc_node_info *":
    """sbmc_node_info_assoc_find(hash_ptr a, node_ptr n) -> sbmc_node_info *"""
    return _sbmc.sbmc_node_info_assoc_find(a, n)

def sbmc_node_info_assoc_insert(a: 'hash_ptr', n: 'node_ptr', i: 'sbmc_node_info *') -> "void":
    """sbmc_node_info_assoc_insert(hash_ptr a, node_ptr n, sbmc_node_info * i)"""
    return _sbmc.sbmc_node_info_assoc_insert(a, n, i)

def sbmc_node_info_assoc_free(a: 'hash_ptr *') -> "void":
    """sbmc_node_info_assoc_free(hash_ptr * a)"""
    return _sbmc.sbmc_node_info_assoc_free(a)

def sbmc_node_info_assoc_create() -> "hash_ptr":
    """sbmc_node_info_assoc_create() -> hash_ptr"""
    return _sbmc.sbmc_node_info_assoc_create()

def Bmc_SBMCTableau_GetNoLoop(be_fsm: 'BeFsm_ptr const', ltl_wff: 'node_ptr const', k: 'int const') -> "be_ptr":
    """Bmc_SBMCTableau_GetNoLoop(BeFsm_ptr const be_fsm, node_ptr const ltl_wff, int const k) -> be_ptr"""
    return _sbmc.Bmc_SBMCTableau_GetNoLoop(be_fsm, ltl_wff, k)

def Bmc_SBMCTableau_GetSingleLoop(be_fsm: 'BeFsm_ptr const', ltl_wff: 'node_ptr const', k: 'int const', l: 'int const') -> "be_ptr":
    """Bmc_SBMCTableau_GetSingleLoop(BeFsm_ptr const be_fsm, node_ptr const ltl_wff, int const k, int const l) -> be_ptr"""
    return _sbmc.Bmc_SBMCTableau_GetSingleLoop(be_fsm, ltl_wff, k, l)

def Bmc_SBMCTableau_GetAllLoops(be_fsm: 'BeFsm_ptr const', ltl_wff: 'node_ptr const', k: 'int const', l: 'int const') -> "be_ptr":
    """Bmc_SBMCTableau_GetAllLoops(BeFsm_ptr const be_fsm, node_ptr const ltl_wff, int const k, int const l) -> be_ptr"""
    return _sbmc.Bmc_SBMCTableau_GetAllLoops(be_fsm, ltl_wff, k, l)

def Bmc_SBMCTableau_GetLoopCondition(be_enc: 'BeEnc_ptr const', k: 'int const', l: 'int const') -> "be_ptr":
    """Bmc_SBMCTableau_GetLoopCondition(BeEnc_ptr const be_enc, int const k, int const l) -> be_ptr"""
    return _sbmc.Bmc_SBMCTableau_GetLoopCondition(be_enc, k, l)
sbmc_SNH_text = _sbmc.sbmc_SNH_text
sbmc_SNYI_text = _sbmc.sbmc_SNYI_text

def sbmc_equal_vectors_formula(be_enc: 'BeEnc_ptr const', vars: 'lsList', i: 'unsigned int const', j: 'unsigned int const') -> "be_ptr":
    """sbmc_equal_vectors_formula(BeEnc_ptr const be_enc, lsList vars, unsigned int const i, unsigned int const j) -> be_ptr"""
    return _sbmc.sbmc_equal_vectors_formula(be_enc, vars, i, j)

def sbmc_init_LTL_info(layer: 'SymbLayer_ptr', ltlspec: 'node_ptr', state_vars_formula_pd0: 'lsList', state_vars_formula_pdx: 'lsList', state_vars_formula_aux: 'lsList', opt_force_state_vars: 'int const', opt_do_virtual_unrolling: 'int const') -> "hash_ptr":
    """sbmc_init_LTL_info(SymbLayer_ptr layer, node_ptr ltlspec, lsList state_vars_formula_pd0, lsList state_vars_formula_pdx, lsList state_vars_formula_aux, int const opt_force_state_vars, int const opt_do_virtual_unrolling) -> hash_ptr"""
    return _sbmc.sbmc_init_LTL_info(layer, ltlspec, state_vars_formula_pd0, state_vars_formula_pdx, state_vars_formula_aux, opt_force_state_vars, opt_do_virtual_unrolling)

def sbmc_init_state_vector(be_enc: 'BeEnc_ptr const', ltlspec: 'node_ptr const', info_map: 'hash_ptr const', i_real: 'unsigned int const', LastState_var: 'node_ptr const', be_LoopExists: 'be_ptr const') -> "void":
    """sbmc_init_state_vector(BeEnc_ptr const be_enc, node_ptr const ltlspec, hash_ptr const info_map, unsigned int const i_real, node_ptr const LastState_var, be_ptr const be_LoopExists)"""
    return _sbmc.sbmc_init_state_vector(be_enc, ltlspec, info_map, i_real, LastState_var, be_LoopExists)

def sbmc_build_InLoop_i(be_enc: 'BeEnc_ptr const', state_vars: 'state_vars_struct const *', InLoop_array: 'array_t *', i_model: 'unsigned int const') -> "be_ptr":
    """sbmc_build_InLoop_i(BeEnc_ptr const be_enc, state_vars_struct const * state_vars, array_t * InLoop_array, unsigned int const i_model) -> be_ptr"""
    return _sbmc.sbmc_build_InLoop_i(be_enc, state_vars, InLoop_array, i_model)

def sbmc_SimplePaths(be_enc: 'BeEnc_ptr const', state_vars: 'state_vars_struct const *', InLoop_array: 'array_t *', k: 'unsigned int const') -> "lsList":
    """sbmc_SimplePaths(BeEnc_ptr const be_enc, state_vars_struct const * state_vars, array_t * InLoop_array, unsigned int const k) -> lsList"""
    return _sbmc.sbmc_SimplePaths(be_enc, state_vars, InLoop_array, k)

def sbmc_unroll_base(be_enc: 'BeEnc_ptr const', ltlspec: 'node_ptr const', info_map: 'hash_ptr const', be_LoopExists: 'be_ptr const', do_optimization: 'int const') -> "lsList":
    """sbmc_unroll_base(BeEnc_ptr const be_enc, node_ptr const ltlspec, hash_ptr const info_map, be_ptr const be_LoopExists, int const do_optimization) -> lsList"""
    return _sbmc.sbmc_unroll_base(be_enc, ltlspec, info_map, be_LoopExists, do_optimization)

def sbmc_unroll_invariant_f(be_enc: 'BeEnc_ptr const', ltlspec: 'node_ptr const', i_model: 'unsigned int const', info_map: 'hash_ptr const', be_InLoop_i: 'be_ptr const', be_l_i: 'be_ptr const', do_optimization: 'int const') -> "lsList":
    """sbmc_unroll_invariant_f(BeEnc_ptr const be_enc, node_ptr const ltlspec, unsigned int const i_model, hash_ptr const info_map, be_ptr const be_InLoop_i, be_ptr const be_l_i, int const do_optimization) -> lsList"""
    return _sbmc.sbmc_unroll_invariant_f(be_enc, ltlspec, i_model, info_map, be_InLoop_i, be_l_i, do_optimization)

def sbmc_unroll_invariant_p(be_enc: 'BeEnc_ptr const', ltlspec: 'node_ptr const', i_model: 'unsigned int const', info_map: 'hash_ptr const', be_InLoop_i: 'be_ptr const', be_l_i: 'be_ptr const', do_optimization: 'int const') -> "lsList":
    """sbmc_unroll_invariant_p(BeEnc_ptr const be_enc, node_ptr const ltlspec, unsigned int const i_model, hash_ptr const info_map, be_ptr const be_InLoop_i, be_ptr const be_l_i, int const do_optimization) -> lsList"""
    return _sbmc.sbmc_unroll_invariant_p(be_enc, ltlspec, i_model, info_map, be_InLoop_i, be_l_i, do_optimization)

def sbmc_formula_dependent(be_enc: 'BeEnc_ptr const', ltlspec: 'node_ptr const', k_model: 'unsigned int const', info_map: 'hash_ptr const') -> "lsList":
    """sbmc_formula_dependent(BeEnc_ptr const be_enc, node_ptr const ltlspec, unsigned int const k_model, hash_ptr const info_map) -> lsList"""
    return _sbmc.sbmc_formula_dependent(be_enc, ltlspec, k_model, info_map)

def sbmc_unroll_invariant(be_enc: 'BeEnc_ptr const', bltlspec: 'node_ptr const', previous_k: 'int const', new_k: 'int const', state_vars: 'state_vars_struct const *', InLoop_array: 'array_t *', info_map: 'hash_ptr const', be_LoopExists: 'be_ptr const', opt_do_optimization: 'int const') -> "lsList":
    """sbmc_unroll_invariant(BeEnc_ptr const be_enc, node_ptr const bltlspec, int const previous_k, int const new_k, state_vars_struct const * state_vars, array_t * InLoop_array, hash_ptr const info_map, be_ptr const be_LoopExists, int const opt_do_optimization) -> lsList"""
    return _sbmc.sbmc_unroll_invariant(be_enc, bltlspec, previous_k, new_k, state_vars, InLoop_array, info_map, be_LoopExists, opt_do_optimization)

def sbmc_dependent(be_enc: 'BeEnc_ptr const', bltlspec: 'node_ptr const', k: 'int const', state_vars: 'state_vars_struct const *', InLoop_array: 'array_t *', be_LoopExists: 'be_ptr const', info_map: 'hash_ptr const') -> "lsList":
    """sbmc_dependent(BeEnc_ptr const be_enc, node_ptr const bltlspec, int const k, state_vars_struct const * state_vars, array_t * InLoop_array, be_ptr const be_LoopExists, hash_ptr const info_map) -> lsList"""
    return _sbmc.sbmc_dependent(be_enc, bltlspec, k, state_vars, InLoop_array, be_LoopExists, info_map)

def sbmc_get_unique_id() -> "int":
    """sbmc_get_unique_id() -> int"""
    return _sbmc.sbmc_get_unique_id()

def sbmc_reset_unique_id() -> "void":
    """sbmc_reset_unique_id()"""
    return _sbmc.sbmc_reset_unique_id()

def sbmc_increment_unique_id() -> "void":
    """sbmc_increment_unique_id()"""
    return _sbmc.sbmc_increment_unique_id()

def sbmc_print_node(out: 'FILE *', prefix: 'char const *', node: 'node_ptr', postfix: 'char const *') -> "void":
    """sbmc_print_node(FILE * out, char const * prefix, node_ptr node, char const * postfix)"""
    return _sbmc.sbmc_print_node(out, prefix, node, postfix)

def sbmc_print_node_list(out: 'FILE *', l: 'lsList') -> "void":
    """sbmc_print_node_list(FILE * out, lsList l)"""
    return _sbmc.sbmc_print_node_list(out, l)

def sbmc_add_new_state_variable(layer: 'SymbLayer_ptr', name: 'char *') -> "node_ptr":
    """sbmc_add_new_state_variable(SymbLayer_ptr layer, char * name) -> node_ptr"""
    return _sbmc.sbmc_add_new_state_variable(layer, name)

def sbmc_find_formula_vars(ltlspec: 'node_ptr') -> "lsList":
    """sbmc_find_formula_vars(node_ptr ltlspec) -> lsList"""
    return _sbmc.sbmc_find_formula_vars(ltlspec)

def sbmc_print_varmap(out: 'FILE *', node: 'node_ptr', info: 'sbmc_node_info *') -> "void":
    """sbmc_print_varmap(FILE * out, node_ptr node, sbmc_node_info * info)"""
    return _sbmc.sbmc_print_varmap(out, node, info)

def sbmc_print_Gvarmap(out: 'FILE *', var: 'node_ptr', formula: 'node_ptr') -> "void":
    """sbmc_print_Gvarmap(FILE * out, node_ptr var, node_ptr formula)"""
    return _sbmc.sbmc_print_Gvarmap(out, var, formula)

def sbmc_print_Fvarmap(out: 'FILE *', var: 'node_ptr', formula: 'node_ptr') -> "void":
    """sbmc_print_Fvarmap(FILE * out, node_ptr var, node_ptr formula)"""
    return _sbmc.sbmc_print_Fvarmap(out, var, formula)

def sbmc_1_fresh_state_var(layer: 'SymbLayer_ptr', index: 'unsigned int *') -> "node_ptr":
    """sbmc_1_fresh_state_var(SymbLayer_ptr layer, unsigned int * index) -> node_ptr"""
    return _sbmc.sbmc_1_fresh_state_var(layer, index)

def sbmc_n_fresh_state_vars(layer: 'SymbLayer_ptr', n: 'unsigned int const', index: 'unsigned int *') -> "array_t *":
    """sbmc_n_fresh_state_vars(SymbLayer_ptr layer, unsigned int const n, unsigned int * index) -> array_t *"""
    return _sbmc.sbmc_n_fresh_state_vars(layer, n, index)

def sbmc_allocate_trans_vars(info: 'sbmc_node_info *', layer: 'SymbLayer_ptr', state_vars_formula_pd0: 'lsList', state_vars_formula_pdx: 'lsList', new_var_index: 'unsigned int *') -> "void":
    """sbmc_allocate_trans_vars(sbmc_node_info * info, SymbLayer_ptr layer, lsList state_vars_formula_pd0, lsList state_vars_formula_pdx, unsigned int * new_var_index)"""
    return _sbmc.sbmc_allocate_trans_vars(info, layer, state_vars_formula_pd0, state_vars_formula_pdx, new_var_index)

def sbmc_make_boolean_formula(ltlprop: 'Prop_ptr') -> "node_ptr":
    """sbmc_make_boolean_formula(Prop_ptr ltlprop) -> node_ptr"""
    return _sbmc.sbmc_make_boolean_formula(ltlprop)

def sbmc_find_relevant_vars(svs: 'state_vars_struct *', be_fsm: 'BeFsm_ptr', bltlspec: 'node_ptr') -> "void":
    """sbmc_find_relevant_vars(state_vars_struct * svs, BeFsm_ptr be_fsm, node_ptr bltlspec)"""
    return _sbmc.sbmc_find_relevant_vars(svs, be_fsm, bltlspec)

def Sbmc_Utils_generate_cntexample(be_enc: 'BeEnc_ptr', solver: 'sbmc_MetaSolver *', l_var: 'node_ptr', k: 'int const', trace_name: 'char const *', symbols: 'NodeList_ptr') -> "Trace_ptr":
    """Sbmc_Utils_generate_cntexample(BeEnc_ptr be_enc, sbmc_MetaSolver * solver, node_ptr l_var, int const k, char const * trace_name, NodeList_ptr symbols) -> Trace_ptr"""
    return _sbmc.Sbmc_Utils_generate_cntexample(be_enc, solver, l_var, k, trace_name, symbols)

def Sbmc_Utils_generate_and_print_cntexample(be_enc: 'BeEnc_ptr', solver: 'sbmc_MetaSolver *', l_var: 'node_ptr', k: 'int const', trace_name: 'char const *', symbols: 'NodeList_ptr') -> "Trace_ptr":
    """Sbmc_Utils_generate_and_print_cntexample(BeEnc_ptr be_enc, sbmc_MetaSolver * solver, node_ptr l_var, int const k, char const * trace_name, NodeList_ptr symbols) -> Trace_ptr"""
    return _sbmc.Sbmc_Utils_generate_and_print_cntexample(be_enc, solver, l_var, k, trace_name, symbols)

def Sbmc_Utils_fill_cntexample(be_enc: 'BeEnc_ptr', solver: 'sbmc_MetaSolver *', l_var: 'node_ptr', k: 'int const', trace: 'Trace_ptr') -> "Trace_ptr":
    """Sbmc_Utils_fill_cntexample(BeEnc_ptr be_enc, sbmc_MetaSolver * solver, node_ptr l_var, int const k, Trace_ptr trace) -> Trace_ptr"""
    return _sbmc.Sbmc_Utils_fill_cntexample(be_enc, solver, l_var, k, trace)

def sbmc_L_state() -> "int":
    """sbmc_L_state() -> int"""
    return _sbmc.sbmc_L_state()

def sbmc_E_state() -> "int":
    """sbmc_E_state() -> int"""
    return _sbmc.sbmc_E_state()

def sbmc_real_k(k: 'int') -> "int":
    """sbmc_real_k(int k) -> int"""
    return _sbmc.sbmc_real_k(k)

def sbmc_model_k(k: 'int') -> "unsigned int":
    """sbmc_model_k(int k) -> unsigned int"""
    return _sbmc.sbmc_model_k(k)

def sbmc_real_k_string(k_real: 'unsigned int const') -> "char *":
    """sbmc_real_k_string(unsigned int const k_real) -> char *"""
    return _sbmc.sbmc_real_k_string(k_real)

def sbmc_MS_create(be_enc: 'BeEnc_ptr') -> "sbmc_MetaSolver *":
    """sbmc_MS_create(BeEnc_ptr be_enc) -> sbmc_MetaSolver *"""
    return _sbmc.sbmc_MS_create(be_enc)

def sbmc_MS_destroy(ms: 'sbmc_MetaSolver *') -> "void":
    """sbmc_MS_destroy(sbmc_MetaSolver * ms)"""
    return _sbmc.sbmc_MS_destroy(ms)

def sbmc_MS_create_volatile_group(ms: 'sbmc_MetaSolver *') -> "void":
    """sbmc_MS_create_volatile_group(sbmc_MetaSolver * ms)"""
    return _sbmc.sbmc_MS_create_volatile_group(ms)

def sbmc_MS_destroy_volatile_group(ms: 'sbmc_MetaSolver *') -> "void":
    """sbmc_MS_destroy_volatile_group(sbmc_MetaSolver * ms)"""
    return _sbmc.sbmc_MS_destroy_volatile_group(ms)

def sbmc_MS_switch_to_permanent_group(ms: 'sbmc_MetaSolver *') -> "void":
    """sbmc_MS_switch_to_permanent_group(sbmc_MetaSolver * ms)"""
    return _sbmc.sbmc_MS_switch_to_permanent_group(ms)

def sbmc_MS_switch_to_volatile_group(ms: 'sbmc_MetaSolver *') -> "void":
    """sbmc_MS_switch_to_volatile_group(sbmc_MetaSolver * ms)"""
    return _sbmc.sbmc_MS_switch_to_volatile_group(ms)

def sbmc_MS_goto_permanent_group(ms: 'sbmc_MetaSolver *') -> "void":
    """sbmc_MS_goto_permanent_group(sbmc_MetaSolver * ms)"""
    return _sbmc.sbmc_MS_goto_permanent_group(ms)

def sbmc_MS_goto_volatile_group(ms: 'sbmc_MetaSolver *') -> "void":
    """sbmc_MS_goto_volatile_group(sbmc_MetaSolver * ms)"""
    return _sbmc.sbmc_MS_goto_volatile_group(ms)

def sbmc_MS_force_true(ms: 'sbmc_MetaSolver *', be_constraint: 'be_ptr') -> "void":
    """sbmc_MS_force_true(sbmc_MetaSolver * ms, be_ptr be_constraint)"""
    return _sbmc.sbmc_MS_force_true(ms, be_constraint)

def sbmc_MS_force_constraint_list(ms: 'sbmc_MetaSolver *', constraints: 'lsList') -> "void":
    """sbmc_MS_force_constraint_list(sbmc_MetaSolver * ms, lsList constraints)"""
    return _sbmc.sbmc_MS_force_constraint_list(ms, constraints)

def sbmc_MS_solve(ms: 'sbmc_MetaSolver *') -> "SatSolverResult":
    """sbmc_MS_solve(sbmc_MetaSolver * ms) -> SatSolverResult"""
    return _sbmc.sbmc_MS_solve(ms)

def sbmc_MS_solve_assume(ms: 'sbmc_MetaSolver *', assumptions: 'Slist_ptr') -> "SatSolverResult":
    """sbmc_MS_solve_assume(sbmc_MetaSolver * ms, Slist_ptr assumptions) -> SatSolverResult"""
    return _sbmc.sbmc_MS_solve_assume(ms, assumptions)

def sbmc_MS_get_solver(ms: 'sbmc_MetaSolver *') -> "SatSolver_ptr":
    """sbmc_MS_get_solver(sbmc_MetaSolver * ms) -> SatSolver_ptr"""
    return _sbmc.sbmc_MS_get_solver(ms)

def sbmc_MS_get_conflicts(ms: 'sbmc_MetaSolver *') -> "Slist_ptr":
    """sbmc_MS_get_conflicts(sbmc_MetaSolver * ms) -> Slist_ptr"""
    return _sbmc.sbmc_MS_get_conflicts(ms)

def sbmc_MS_get_model(ms: 'sbmc_MetaSolver *') -> "Slist_ptr":
    """sbmc_MS_get_model(sbmc_MetaSolver * ms) -> Slist_ptr"""
    return _sbmc.sbmc_MS_get_model(ms)

def sbmc_add_loop_variable(fsm: 'BeFsm_ptr') -> "void":
    """sbmc_add_loop_variable(BeFsm_ptr fsm)"""
    return _sbmc.sbmc_add_loop_variable(fsm)

def sbmc_remove_loop_variable(fsm: 'BeFsm_ptr') -> "void":
    """sbmc_remove_loop_variable(BeFsm_ptr fsm)"""
    return _sbmc.sbmc_remove_loop_variable(fsm)

def sbmc_loop_var_name_set(n: 'node_ptr') -> "void":
    """sbmc_loop_var_name_set(node_ptr n)"""
    return _sbmc.sbmc_loop_var_name_set(n)

def sbmc_loop_var_name_get() -> "node_ptr":
    """sbmc_loop_var_name_get() -> node_ptr"""
    return _sbmc.sbmc_loop_var_name_get()
# This file is compatible with both classic and new-style classes.


