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

def TracePkg_init() -> "void":
    """TracePkg_init()"""
    return _trace.TracePkg_init()

def TracePkg_quit() -> "void":
    """TracePkg_quit()"""
    return _trace.TracePkg_quit()

def traceCmd_init() -> "void":
    """traceCmd_init()"""
    return _trace.traceCmd_init()

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

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

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

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

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

def TracePkg_get_filtered_symbols(symbols: 'NodeList_ptr const') -> "NodeList_ptr":
    """TracePkg_get_filtered_symbols(NodeList_ptr const symbols) -> NodeList_ptr"""
    return _trace.TracePkg_get_filtered_symbols(symbols)

def TracePkg_get_global_trace_manager() -> "TraceManager_ptr":
    """TracePkg_get_global_trace_manager() -> TraceManager_ptr"""
    return _trace.TracePkg_get_global_trace_manager()

def TracePkg_get_default_trace_plugin() -> "int":
    """TracePkg_get_default_trace_plugin() -> int"""
    return _trace.TracePkg_get_default_trace_plugin()

def TracePkg_set_default_trace_plugin(dp: 'int') -> "boolean":
    """TracePkg_set_default_trace_plugin(int dp) -> boolean"""
    return _trace.TracePkg_set_default_trace_plugin(dp)

def Trace_execute_trace(trace: 'Trace_ptr', exec_info: 'CompleteTraceExecutor_ptr') -> "int":
    """Trace_execute_trace(Trace_ptr trace, CompleteTraceExecutor_ptr exec_info) -> int"""
    return _trace.Trace_execute_trace(trace, exec_info)

def Trace_execute_partial_trace(trace: 'Trace_ptr', exec_info: 'PartialTraceExecutor_ptr', language: 'NodeList_ptr') -> "int":
    """Trace_execute_partial_trace(Trace_ptr trace, PartialTraceExecutor_ptr exec_info, NodeList_ptr language) -> int"""
    return _trace.Trace_execute_partial_trace(trace, exec_info, language)

def TraceUtils_fetch_as_bdd(trace: 'Trace_ptr', step: 'TraceIter', iter_type: 'TraceIteratorType', bdd_enc: 'BddEnc_ptr') -> "bdd_ptr":
    """TraceUtils_fetch_as_bdd(Trace_ptr trace, TraceIter step, TraceIteratorType iter_type, BddEnc_ptr bdd_enc) -> bdd_ptr"""
    return _trace.TraceUtils_fetch_as_bdd(trace, step, iter_type, bdd_enc)

def TraceUtils_fetch_as_be(trace: 'Trace_ptr', step: 'TraceIter', iter_type: 'TraceIteratorType', be_enc: 'BeEnc_ptr', bdd_enc: 'BddEnc_ptr') -> "be_ptr":
    """TraceUtils_fetch_as_be(Trace_ptr trace, TraceIter step, TraceIteratorType iter_type, BeEnc_ptr be_enc, BddEnc_ptr bdd_enc) -> be_ptr"""
    return _trace.TraceUtils_fetch_as_be(trace, step, iter_type, be_enc, bdd_enc)

def TraceUtils_fetch_as_sexp(trace: 'Trace_ptr', step: 'TraceIter', iter_type: 'TraceIteratorType') -> "Expr_ptr":
    """TraceUtils_fetch_as_sexp(Trace_ptr trace, TraceIter step, TraceIteratorType iter_type) -> Expr_ptr"""
    return _trace.TraceUtils_fetch_as_sexp(trace, step, iter_type)

def TraceUtils_fetch_as_big_and(trace: 'Trace_ptr', step: 'TraceIter', iter_type: 'TraceIteratorType') -> "Expr_ptr":
    """TraceUtils_fetch_as_big_and(Trace_ptr trace, TraceIter step, TraceIteratorType iter_type) -> Expr_ptr"""
    return _trace.TraceUtils_fetch_as_big_and(trace, step, iter_type)
TRACE_TYPE_UNSPECIFIED = _trace.TRACE_TYPE_UNSPECIFIED
TRACE_TYPE_CNTEXAMPLE = _trace.TRACE_TYPE_CNTEXAMPLE
TRACE_TYPE_SIMULATION = _trace.TRACE_TYPE_SIMULATION
TRACE_TYPE_EXECUTION = _trace.TRACE_TYPE_EXECUTION
TRACE_TYPE_END = _trace.TRACE_TYPE_END
TRACE_ITER_NONE = _trace.TRACE_ITER_NONE
TRACE_ITER_F_VARS = _trace.TRACE_ITER_F_VARS
TRACE_ITER_S_VARS = _trace.TRACE_ITER_S_VARS
TRACE_ITER_I_VARS = _trace.TRACE_ITER_I_VARS
TRACE_ITER_SF_VARS = _trace.TRACE_ITER_SF_VARS
TRACE_ITER_ALL_VARS = _trace.TRACE_ITER_ALL_VARS
TRACE_ITER_S_DEFINES = _trace.TRACE_ITER_S_DEFINES
TRACE_ITER_I_DEFINES = _trace.TRACE_ITER_I_DEFINES
TRACE_ITER_SI_DEFINES = _trace.TRACE_ITER_SI_DEFINES
TRACE_ITER_N_DEFINES = _trace.TRACE_ITER_N_DEFINES
TRACE_ITER_SN_DEFINES = _trace.TRACE_ITER_SN_DEFINES
TRACE_ITER_IN_DEFINES = _trace.TRACE_ITER_IN_DEFINES
TRACE_ITER_SIN_DEFINES = _trace.TRACE_ITER_SIN_DEFINES
TRACE_ITER_SF_SYMBOLS = _trace.TRACE_ITER_SF_SYMBOLS
TRACE_ITER_S_SYMBOLS = _trace.TRACE_ITER_S_SYMBOLS
TRACE_ITER_I_SYMBOLS = _trace.TRACE_ITER_I_SYMBOLS
TRACE_ITER_COMBINATORIAL = _trace.TRACE_ITER_COMBINATORIAL
TRACE_ITER_TRANSITIONAL = _trace.TRACE_ITER_TRANSITIONAL
class TraceStepIter(_object):
    """Proxy of C TraceStepIter_TAG struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TraceStepIter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TraceStepIter, name)
    __repr__ = _swig_repr
    __swig_setmethods__["trace"] = _trace.TraceStepIter_trace_set
    __swig_getmethods__["trace"] = _trace.TraceStepIter_trace_get
    if _newclass:
        trace = _swig_property(_trace.TraceStepIter_trace_get, _trace.TraceStepIter_trace_set)
    __swig_setmethods__["step"] = _trace.TraceStepIter_step_set
    __swig_getmethods__["step"] = _trace.TraceStepIter_step_get
    if _newclass:
        step = _swig_property(_trace.TraceStepIter_step_get, _trace.TraceStepIter_step_set)
    __swig_setmethods__["type"] = _trace.TraceStepIter_type_set
    __swig_getmethods__["type"] = _trace.TraceStepIter_type_get
    if _newclass:
        type = _swig_property(_trace.TraceStepIter_type_get, _trace.TraceStepIter_type_set)
    __swig_setmethods__["section"] = _trace.TraceStepIter_section_set
    __swig_getmethods__["section"] = _trace.TraceStepIter_section_get
    if _newclass:
        section = _swig_property(_trace.TraceStepIter_section_get, _trace.TraceStepIter_section_set)
    __swig_setmethods__["cursor"] = _trace.TraceStepIter_cursor_set
    __swig_getmethods__["cursor"] = _trace.TraceStepIter_cursor_get
    if _newclass:
        cursor = _swig_property(_trace.TraceStepIter_cursor_get, _trace.TraceStepIter_cursor_set)

    def __init__(self):
        """__init__(TraceStepIter_TAG self) -> TraceStepIter"""
        this = _trace.new_TraceStepIter()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _trace.delete_TraceStepIter
    __del__ = lambda self: None
TraceStepIter_swigregister = _trace.TraceStepIter_swigregister
TraceStepIter_swigregister(TraceStepIter)

class TraceSymbolsIter(_object):
    """Proxy of C TraceSymbolsIter_TAG struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TraceSymbolsIter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TraceSymbolsIter, name)
    __repr__ = _swig_repr
    __swig_setmethods__["trace"] = _trace.TraceSymbolsIter_trace_set
    __swig_getmethods__["trace"] = _trace.TraceSymbolsIter_trace_get
    if _newclass:
        trace = _swig_property(_trace.TraceSymbolsIter_trace_get, _trace.TraceSymbolsIter_trace_set)
    __swig_setmethods__["type"] = _trace.TraceSymbolsIter_type_set
    __swig_getmethods__["type"] = _trace.TraceSymbolsIter_type_get
    if _newclass:
        type = _swig_property(_trace.TraceSymbolsIter_type_get, _trace.TraceSymbolsIter_type_set)
    __swig_setmethods__["section"] = _trace.TraceSymbolsIter_section_set
    __swig_getmethods__["section"] = _trace.TraceSymbolsIter_section_get
    if _newclass:
        section = _swig_property(_trace.TraceSymbolsIter_section_get, _trace.TraceSymbolsIter_section_set)
    __swig_setmethods__["cursor"] = _trace.TraceSymbolsIter_cursor_set
    __swig_getmethods__["cursor"] = _trace.TraceSymbolsIter_cursor_get
    if _newclass:
        cursor = _swig_property(_trace.TraceSymbolsIter_cursor_get, _trace.TraceSymbolsIter_cursor_set)

    def __init__(self):
        """__init__(TraceSymbolsIter_TAG self) -> TraceSymbolsIter"""
        this = _trace.new_TraceSymbolsIter()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _trace.delete_TraceSymbolsIter
    __del__ = lambda self: None
TraceSymbolsIter_swigregister = _trace.TraceSymbolsIter_swigregister
TraceSymbolsIter_swigregister(TraceSymbolsIter)

TRACE_UNREGISTERED = _trace.TRACE_UNREGISTERED

def Trace_create(st: 'SymbTable_ptr', desc: 'char const *', type: 'TraceType const', symbols: 'NodeList_ptr', is_volatile: 'boolean') -> "Trace_ptr":
    """Trace_create(SymbTable_ptr st, char const * desc, TraceType const type, NodeList_ptr symbols, boolean is_volatile) -> Trace_ptr"""
    return _trace.Trace_create(st, desc, type, symbols, is_volatile)

def Trace_copy(arg1: 'Trace_ptr const', until_here: 'TraceIter const', is_volatile: 'boolean') -> "Trace_ptr":
    """Trace_copy(Trace_ptr const arg1, TraceIter const until_here, boolean is_volatile) -> Trace_ptr"""
    return _trace.Trace_copy(arg1, until_here, is_volatile)

def Trace_concat(arg1: 'Trace_ptr', other: 'Trace_ptr *') -> "Trace_ptr":
    """Trace_concat(Trace_ptr arg1, Trace_ptr * other) -> Trace_ptr"""
    return _trace.Trace_concat(arg1, other)

def Trace_destroy(arg1: 'Trace_ptr') -> "void":
    """Trace_destroy(Trace_ptr arg1)"""
    return _trace.Trace_destroy(arg1)

def Trace_get_desc(arg1: 'Trace_ptr const') -> "char const *":
    """Trace_get_desc(Trace_ptr const arg1) -> char const *"""
    return _trace.Trace_get_desc(arg1)

def Trace_set_desc(arg1: 'Trace_ptr const', desc: 'char const *') -> "void":
    """Trace_set_desc(Trace_ptr const arg1, char const * desc)"""
    return _trace.Trace_set_desc(arg1, desc)

def Trace_is_volatile(arg1: 'Trace_ptr const') -> "boolean":
    """Trace_is_volatile(Trace_ptr const arg1) -> boolean"""
    return _trace.Trace_is_volatile(arg1)

def Trace_get_id(arg1: 'Trace_ptr const') -> "int":
    """Trace_get_id(Trace_ptr const arg1) -> int"""
    return _trace.Trace_get_id(arg1)

def Trace_is_registered(arg1: 'Trace_ptr const') -> "boolean":
    """Trace_is_registered(Trace_ptr const arg1) -> boolean"""
    return _trace.Trace_is_registered(arg1)

def Trace_register(arg1: 'Trace_ptr const', id: 'int') -> "void":
    """Trace_register(Trace_ptr const arg1, int id)"""
    return _trace.Trace_register(arg1, id)

def Trace_unregister(arg1: 'Trace_ptr const') -> "void":
    """Trace_unregister(Trace_ptr const arg1)"""
    return _trace.Trace_unregister(arg1)

def Trace_get_type(arg1: 'Trace_ptr const') -> "TraceType":
    """Trace_get_type(Trace_ptr const arg1) -> TraceType"""
    return _trace.Trace_get_type(arg1)

def Trace_set_type(arg1: 'Trace_ptr', trace_type: 'TraceType') -> "void":
    """Trace_set_type(Trace_ptr arg1, TraceType trace_type)"""
    return _trace.Trace_set_type(arg1, trace_type)

def Trace_get_length(arg1: 'Trace_ptr const') -> "unsigned int":
    """Trace_get_length(Trace_ptr const arg1) -> unsigned int"""
    return _trace.Trace_get_length(arg1)

def Trace_is_empty(arg1: 'Trace_ptr const') -> "boolean":
    """Trace_is_empty(Trace_ptr const arg1) -> boolean"""
    return _trace.Trace_is_empty(arg1)

def Trace_is_frozen(arg1: 'Trace_ptr const') -> "boolean":
    """Trace_is_frozen(Trace_ptr const arg1) -> boolean"""
    return _trace.Trace_is_frozen(arg1)

def Trace_is_thawed(arg1: 'Trace_ptr const') -> "boolean":
    """Trace_is_thawed(Trace_ptr const arg1) -> boolean"""
    return _trace.Trace_is_thawed(arg1)

def Trace_freeze(arg1: 'Trace_ptr') -> "void":
    """Trace_freeze(Trace_ptr arg1)"""
    return _trace.Trace_freeze(arg1)

def Trace_thaw(arg1: 'Trace_ptr') -> "void":
    """Trace_thaw(Trace_ptr arg1)"""
    return _trace.Trace_thaw(arg1)

def Trace_equals(arg1: 'Trace_ptr const', other: 'Trace_ptr const') -> "boolean":
    """Trace_equals(Trace_ptr const arg1, Trace_ptr const other) -> boolean"""
    return _trace.Trace_equals(arg1, other)

def Trace_append_step(arg1: 'Trace_ptr') -> "TraceIter":
    """Trace_append_step(Trace_ptr arg1) -> TraceIter"""
    return _trace.Trace_append_step(arg1)

def Trace_step_is_loopback(arg1: 'Trace_ptr const', step: 'TraceIter') -> "boolean":
    """Trace_step_is_loopback(Trace_ptr const arg1, TraceIter step) -> boolean"""
    return _trace.Trace_step_is_loopback(arg1, step)

def Trace_step_force_loopback(arg1: 'Trace_ptr const', step: 'TraceIter') -> "void":
    """Trace_step_force_loopback(Trace_ptr const arg1, TraceIter step)"""
    return _trace.Trace_step_force_loopback(arg1, step)

def Trace_step_put_value(arg1: 'Trace_ptr', step: 'TraceIter', symb: 'node_ptr', value: 'node_ptr') -> "boolean":
    """Trace_step_put_value(Trace_ptr arg1, TraceIter step, node_ptr symb, node_ptr value) -> boolean"""
    return _trace.Trace_step_put_value(arg1, step, symb, value)

def Trace_step_get_value(arg1: 'Trace_ptr const', step: 'TraceIter', symb: 'node_ptr') -> "node_ptr":
    """Trace_step_get_value(Trace_ptr const arg1, TraceIter step, node_ptr symb) -> node_ptr"""
    return _trace.Trace_step_get_value(arg1, step, symb)

def Trace_first_iter(arg1: 'Trace_ptr const') -> "TraceIter":
    """Trace_first_iter(Trace_ptr const arg1) -> TraceIter"""
    return _trace.Trace_first_iter(arg1)

def Trace_ith_iter(arg1: 'Trace_ptr const', i: 'unsigned int') -> "TraceIter":
    """Trace_ith_iter(Trace_ptr const arg1, unsigned int i) -> TraceIter"""
    return _trace.Trace_ith_iter(arg1, i)

def Trace_last_iter(arg1: 'Trace_ptr const') -> "TraceIter":
    """Trace_last_iter(Trace_ptr const arg1) -> TraceIter"""
    return _trace.Trace_last_iter(arg1)

def TraceIter_get_next(iter: 'TraceIter const') -> "TraceIter":
    """TraceIter_get_next(TraceIter const iter) -> TraceIter"""
    return _trace.TraceIter_get_next(iter)

def TraceIter_get_prev(iter: 'TraceIter const') -> "TraceIter":
    """TraceIter_get_prev(TraceIter const iter) -> TraceIter"""
    return _trace.TraceIter_get_prev(iter)

def TraceIter_is_end(iter: 'TraceIter const') -> "boolean":
    """TraceIter_is_end(TraceIter const iter) -> boolean"""
    return _trace.TraceIter_is_end(iter)

def Trace_step_iter(arg1: 'Trace_ptr const', step: 'TraceIter const', iter_type: 'TraceIteratorType const') -> "TraceStepIter":
    """Trace_step_iter(Trace_ptr const arg1, TraceIter const step, TraceIteratorType const iter_type) -> TraceStepIter"""
    return _trace.Trace_step_iter(arg1, step, iter_type)

def Trace_step_iter_fetch(step_iter: 'TraceStepIter', symb: 'node_ptr *', value: 'node_ptr *') -> "boolean":
    """Trace_step_iter_fetch(TraceStepIter step_iter, node_ptr * symb, node_ptr * value) -> boolean"""
    return _trace.Trace_step_iter_fetch(step_iter, symb, value)

def Trace_symbols_iter(arg1: 'Trace_ptr const', iter_type: 'TraceIteratorType const') -> "TraceSymbolsIter":
    """Trace_symbols_iter(Trace_ptr const arg1, TraceIteratorType const iter_type) -> TraceSymbolsIter"""
    return _trace.Trace_symbols_iter(arg1, iter_type)

def Trace_symbols_iter_fetch(symbols_iter: 'TraceSymbolsIter', symb: 'node_ptr *') -> "boolean":
    """Trace_symbols_iter_fetch(TraceSymbolsIter symbols_iter, node_ptr * symb) -> boolean"""
    return _trace.Trace_symbols_iter_fetch(symbols_iter, symb)

def Trace_get_symb_table(arg1: 'Trace_ptr') -> "SymbTable_ptr":
    """Trace_get_symb_table(Trace_ptr arg1) -> SymbTable_ptr"""
    return _trace.Trace_get_symb_table(arg1)

def Trace_get_symbols(arg1: 'Trace_ptr const') -> "NodeList_ptr":
    """Trace_get_symbols(Trace_ptr const arg1) -> NodeList_ptr"""
    return _trace.Trace_get_symbols(arg1)

def Trace_get_s_vars(arg1: 'Trace_ptr const') -> "NodeList_ptr":
    """Trace_get_s_vars(Trace_ptr const arg1) -> NodeList_ptr"""
    return _trace.Trace_get_s_vars(arg1)

def Trace_get_sf_vars(arg1: 'Trace_ptr const') -> "NodeList_ptr":
    """Trace_get_sf_vars(Trace_ptr const arg1) -> NodeList_ptr"""
    return _trace.Trace_get_sf_vars(arg1)

def Trace_get_i_vars(arg1: 'Trace_ptr const') -> "NodeList_ptr":
    """Trace_get_i_vars(Trace_ptr const arg1) -> NodeList_ptr"""
    return _trace.Trace_get_i_vars(arg1)

def Trace_symbol_in_language(arg1: 'Trace_ptr const', symb: 'node_ptr') -> "boolean":
    """Trace_symbol_in_language(Trace_ptr const arg1, node_ptr symb) -> boolean"""
    return _trace.Trace_symbol_in_language(arg1, symb)

def Trace_is_complete(arg1: 'Trace_ptr', vars: 'NodeList_ptr', report: 'boolean') -> "boolean":
    """Trace_is_complete(Trace_ptr arg1, NodeList_ptr vars, boolean report) -> boolean"""
    return _trace.Trace_is_complete(arg1, vars, report)

def TraceType_to_string(arg1: 'TraceType const') -> "char const *":
    """TraceType_to_string(TraceType const arg1) -> char const *"""
    return _trace.TraceType_to_string(arg1)

def TraceLabel_create(trace_id: 'int', state_id: 'int') -> "TraceLabel":
    """TraceLabel_create(int trace_id, int state_id) -> TraceLabel"""
    return _trace.TraceLabel_create(trace_id, state_id)

def TraceLabel_create_from_string(label_str: 'char const *') -> "TraceLabel":
    """TraceLabel_create_from_string(char const * label_str) -> TraceLabel"""
    return _trace.TraceLabel_create_from_string(label_str)

def TraceLabel_get_state(arg1: 'TraceLabel') -> "int":
    """TraceLabel_get_state(TraceLabel arg1) -> int"""
    return _trace.TraceLabel_get_state(arg1)

def TraceLabel_get_trace(arg1: 'TraceLabel') -> "int":
    """TraceLabel_get_trace(TraceLabel arg1) -> int"""
    return _trace.TraceLabel_get_trace(arg1)
TRACE_MANAGER_DEFAULT_PLUGIN = _trace.TRACE_MANAGER_DEFAULT_PLUGIN
TRACE_MANAGER_LAST_TRACE = _trace.TRACE_MANAGER_LAST_TRACE

def TraceManager_create() -> "TraceManager_ptr":
    """TraceManager_create() -> TraceManager_ptr"""
    return _trace.TraceManager_create()

def TraceManager_destroy(arg1: 'TraceManager_ptr') -> "void":
    """TraceManager_destroy(TraceManager_ptr arg1)"""
    return _trace.TraceManager_destroy(arg1)

def TraceManager_get_size(arg1: 'TraceManager_ptr const') -> "int":
    """TraceManager_get_size(TraceManager_ptr const arg1) -> int"""
    return _trace.TraceManager_get_size(arg1)

def TraceManager_get_plugin_size(arg1: 'TraceManager_ptr const') -> "int":
    """TraceManager_get_plugin_size(TraceManager_ptr const arg1) -> int"""
    return _trace.TraceManager_get_plugin_size(arg1)

def TraceManager_get_internal_plugin_size(arg1: 'TraceManager_ptr const') -> "int":
    """TraceManager_get_internal_plugin_size(TraceManager_ptr const arg1) -> int"""
    return _trace.TraceManager_get_internal_plugin_size(arg1)

def TraceManager_get_trace_at_index(arg1: 'TraceManager_ptr const', index: 'int') -> "Trace_ptr":
    """TraceManager_get_trace_at_index(TraceManager_ptr const arg1, int index) -> Trace_ptr"""
    return _trace.TraceManager_get_trace_at_index(arg1, index)

def TraceManager_get_plugin_at_index(arg1: 'TraceManager_ptr const', index: 'int') -> "TracePlugin_ptr":
    """TraceManager_get_plugin_at_index(TraceManager_ptr const arg1, int index) -> TracePlugin_ptr"""
    return _trace.TraceManager_get_plugin_at_index(arg1, index)

def TraceManager_register_trace(arg1: 'TraceManager_ptr', trace: 'Trace_ptr') -> "int":
    """TraceManager_register_trace(TraceManager_ptr arg1, Trace_ptr trace) -> int"""
    return _trace.TraceManager_register_trace(arg1, trace)

def TraceManager_init_plugins(arg1: 'TraceManager_ptr') -> "void":
    """TraceManager_init_plugins(TraceManager_ptr arg1)"""
    return _trace.TraceManager_init_plugins(arg1)

def TraceManager_register_plugin(arg1: 'TraceManager_ptr', plugin: 'TracePlugin_ptr') -> "int":
    """TraceManager_register_plugin(TraceManager_ptr arg1, TracePlugin_ptr plugin) -> int"""
    return _trace.TraceManager_register_plugin(arg1, plugin)

def TraceManager_get_evaluator(arg1: 'TraceManager_ptr') -> "BaseEvaluator_ptr":
    """TraceManager_get_evaluator(TraceManager_ptr arg1) -> BaseEvaluator_ptr"""
    return _trace.TraceManager_get_evaluator(arg1)

def TraceManager_register_evaluator(arg1: 'TraceManager_ptr', eval: 'BaseEvaluator_ptr') -> "void":
    """TraceManager_register_evaluator(TraceManager_ptr arg1, BaseEvaluator_ptr eval)"""
    return _trace.TraceManager_register_evaluator(arg1, eval)

def TraceManager_unregister_evaluator(arg1: 'TraceManager_ptr') -> "void":
    """TraceManager_unregister_evaluator(TraceManager_ptr arg1)"""
    return _trace.TraceManager_unregister_evaluator(arg1)

def TraceManager_register_complete_trace_executor(arg1: 'TraceManager_ptr', executor_name: 'char const *', executor_desc: 'char const *', executor: 'CompleteTraceExecutor_ptr const') -> "void":
    """TraceManager_register_complete_trace_executor(TraceManager_ptr arg1, char const * executor_name, char const * executor_desc, CompleteTraceExecutor_ptr const executor)"""
    return _trace.TraceManager_register_complete_trace_executor(arg1, executor_name, executor_desc, executor)

def TraceManager_get_complete_trace_executor(arg1: 'TraceManager_ptr const', name: 'char const *') -> "CompleteTraceExecutor_ptr":
    """TraceManager_get_complete_trace_executor(TraceManager_ptr const arg1, char const * name) -> CompleteTraceExecutor_ptr"""
    return _trace.TraceManager_get_complete_trace_executor(arg1, name)

def TraceManager_get_complete_trace_executor_ids(arg1: 'TraceManager_ptr const') -> "array_t *":
    """TraceManager_get_complete_trace_executor_ids(TraceManager_ptr const arg1) -> array_t *"""
    return _trace.TraceManager_get_complete_trace_executor_ids(arg1)

def TraceManager_get_complete_trace_executor_desc(arg1: 'TraceManager_ptr const', name: 'char const *') -> "char const *":
    """TraceManager_get_complete_trace_executor_desc(TraceManager_ptr const arg1, char const * name) -> char const *"""
    return _trace.TraceManager_get_complete_trace_executor_desc(arg1, name)

def TraceManager_get_default_complete_trace_executor(global_trace_manager: 'TraceManager_ptr const') -> "CompleteTraceExecutor_ptr":
    """TraceManager_get_default_complete_trace_executor(TraceManager_ptr const global_trace_manager) -> CompleteTraceExecutor_ptr"""
    return _trace.TraceManager_get_default_complete_trace_executor(global_trace_manager)

def TraceManager_register_partial_trace_executor(arg1: 'TraceManager_ptr', executor_name: 'char const *', executor_desc: 'char const *', executor: 'PartialTraceExecutor_ptr const') -> "void":
    """TraceManager_register_partial_trace_executor(TraceManager_ptr arg1, char const * executor_name, char const * executor_desc, PartialTraceExecutor_ptr const executor)"""
    return _trace.TraceManager_register_partial_trace_executor(arg1, executor_name, executor_desc, executor)

def TraceManager_get_partial_trace_executor_ids(arg1: 'TraceManager_ptr const') -> "array_t *":
    """TraceManager_get_partial_trace_executor_ids(TraceManager_ptr const arg1) -> array_t *"""
    return _trace.TraceManager_get_partial_trace_executor_ids(arg1)

def TraceManager_get_partial_trace_executor(arg1: 'TraceManager_ptr const', name: 'char const *') -> "PartialTraceExecutor_ptr":
    """TraceManager_get_partial_trace_executor(TraceManager_ptr const arg1, char const * name) -> PartialTraceExecutor_ptr"""
    return _trace.TraceManager_get_partial_trace_executor(arg1, name)

def TraceManager_get_partial_trace_executor_desc(arg1: 'TraceManager_ptr const', name: 'char const *') -> "char const *":
    """TraceManager_get_partial_trace_executor_desc(TraceManager_ptr const arg1, char const * name) -> char const *"""
    return _trace.TraceManager_get_partial_trace_executor_desc(arg1, name)

def TraceManager_get_default_partial_trace_executor(global_trace_manager: 'TraceManager_ptr const') -> "PartialTraceExecutor_ptr":
    """TraceManager_get_default_partial_trace_executor(TraceManager_ptr const global_trace_manager) -> PartialTraceExecutor_ptr"""
    return _trace.TraceManager_get_default_partial_trace_executor(global_trace_manager)

def TraceManager_register_layer(arg1: 'TraceManager_ptr', layer_name: 'char const *') -> "void":
    """TraceManager_register_layer(TraceManager_ptr arg1, char const * layer_name)"""
    return _trace.TraceManager_register_layer(arg1, layer_name)

def TraceManager_unregister_layer(arg1: 'TraceManager_ptr', layer_name: 'char const *') -> "void":
    """TraceManager_unregister_layer(TraceManager_ptr arg1, char const * layer_name)"""
    return _trace.TraceManager_unregister_layer(arg1, layer_name)

def TraceManager_is_layer_registered(arg1: 'TraceManager_ptr const', layer_name: 'char const *') -> "boolean":
    """TraceManager_is_layer_registered(TraceManager_ptr const arg1, char const * layer_name) -> boolean"""
    return _trace.TraceManager_is_layer_registered(arg1, layer_name)

def TraceManager_get_registered_layers(arg1: 'TraceManager_ptr const') -> "array_t const *":
    """TraceManager_get_registered_layers(TraceManager_ptr const arg1) -> array_t const *"""
    return _trace.TraceManager_get_registered_layers(arg1)

def TraceManager_execute_plugin(arg1: 'TraceManager_ptr const', opt: 'TraceOpt_ptr const', plugin_index: 'int', trace_index: 'int') -> "int":
    """TraceManager_execute_plugin(TraceManager_ptr const arg1, TraceOpt_ptr const opt, int plugin_index, int trace_index) -> int"""
    return _trace.TraceManager_execute_plugin(arg1, opt, plugin_index, trace_index)

def TraceManager_set_current_trace_number(arg1: 'TraceManager_ptr', trace_id: 'int') -> "void":
    """TraceManager_set_current_trace_number(TraceManager_ptr arg1, int trace_id)"""
    return _trace.TraceManager_set_current_trace_number(arg1, trace_id)

def TraceManager_get_current_trace_number(arg1: 'TraceManager_ptr') -> "int":
    """TraceManager_get_current_trace_number(TraceManager_ptr arg1) -> int"""
    return _trace.TraceManager_get_current_trace_number(arg1)

def TraceManager_set_default_plugin(arg1: 'TraceManager_ptr', plugin_id: 'int') -> "void":
    """TraceManager_set_default_plugin(TraceManager_ptr arg1, int plugin_id)"""
    return _trace.TraceManager_set_default_plugin(arg1, plugin_id)

def TraceManager_get_default_plugin(arg1: 'TraceManager_ptr') -> "int":
    """TraceManager_get_default_plugin(TraceManager_ptr arg1) -> int"""
    return _trace.TraceManager_get_default_plugin(arg1)

def TraceManager_is_visible_symbol(arg1: 'TraceManager_ptr', symbol: 'node_ptr') -> "boolean":
    """TraceManager_is_visible_symbol(TraceManager_ptr arg1, node_ptr symbol) -> boolean"""
    return _trace.TraceManager_is_visible_symbol(arg1, symbol)

def TraceManager_is_label_valid(arg1: 'TraceManager_ptr', label: 'TraceLabel') -> "boolean":
    """TraceManager_is_label_valid(TraceManager_ptr arg1, TraceLabel label) -> boolean"""
    return _trace.TraceManager_is_label_valid(arg1, label)

def TraceManager_is_plugin_internal(arg1: 'TraceManager_ptr const', index: 'int') -> "boolean":
    """TraceManager_is_plugin_internal(TraceManager_ptr const arg1, int index) -> boolean"""
    return _trace.TraceManager_is_plugin_internal(arg1, index)

def TraceManager_get_iterator_from_label(arg1: 'TraceManager_ptr', label: 'TraceLabel') -> "TraceIter":
    """TraceManager_get_iterator_from_label(TraceManager_ptr arg1, TraceLabel label) -> TraceIter"""
    return _trace.TraceManager_get_iterator_from_label(arg1, label)

def TraceManager_get_abs_index_from_label(arg1: 'TraceManager_ptr', label: 'TraceLabel') -> "int":
    """TraceManager_get_abs_index_from_label(TraceManager_ptr arg1, TraceLabel label) -> int"""
    return _trace.TraceManager_get_abs_index_from_label(arg1, label)

def TraceOpt_create() -> "TraceOpt_ptr":
    """TraceOpt_create() -> TraceOpt_ptr"""
    return _trace.TraceOpt_create()

def TraceOpt_create_from_env(opt: 'OptsHandler_ptr') -> "TraceOpt_ptr":
    """TraceOpt_create_from_env(OptsHandler_ptr opt) -> TraceOpt_ptr"""
    return _trace.TraceOpt_create_from_env(opt)

def TraceOpt_update_from_env(arg1: 'TraceOpt_ptr', opt: 'OptsHandler_ptr') -> "void":
    """TraceOpt_update_from_env(TraceOpt_ptr arg1, OptsHandler_ptr opt)"""
    return _trace.TraceOpt_update_from_env(arg1, opt)

def TraceOpt_destroy(arg1: 'TraceOpt_ptr') -> "void":
    """TraceOpt_destroy(TraceOpt_ptr arg1)"""
    return _trace.TraceOpt_destroy(arg1)

def TraceOpt_obfuscate(arg1: 'TraceOpt_ptr') -> "boolean":
    """TraceOpt_obfuscate(TraceOpt_ptr arg1) -> boolean"""
    return _trace.TraceOpt_obfuscate(arg1)

def TraceOpt_set_obfuscate(arg1: 'TraceOpt_ptr', obfuscate: 'boolean') -> "void":
    """TraceOpt_set_obfuscate(TraceOpt_ptr arg1, boolean obfuscate)"""
    return _trace.TraceOpt_set_obfuscate(arg1, obfuscate)

def TraceOpt_show_defines(arg1: 'TraceOpt_ptr') -> "boolean":
    """TraceOpt_show_defines(TraceOpt_ptr arg1) -> boolean"""
    return _trace.TraceOpt_show_defines(arg1)

def TraceOpt_set_show_defines(arg1: 'TraceOpt_ptr', show_defines: 'boolean') -> "void":
    """TraceOpt_set_show_defines(TraceOpt_ptr arg1, boolean show_defines)"""
    return _trace.TraceOpt_set_show_defines(arg1, show_defines)

def TraceOpt_show_defines_with_next(arg1: 'TraceOpt_ptr') -> "boolean":
    """TraceOpt_show_defines_with_next(TraceOpt_ptr arg1) -> boolean"""
    return _trace.TraceOpt_show_defines_with_next(arg1)

def TraceOpt_set_show_defines_with_next(arg1: 'TraceOpt_ptr', show_next: 'boolean') -> "void":
    """TraceOpt_set_show_defines_with_next(TraceOpt_ptr arg1, boolean show_next)"""
    return _trace.TraceOpt_set_show_defines_with_next(arg1, show_next)

def TraceOpt_hiding_prefix(arg1: 'TraceOpt_ptr') -> "char const *":
    """TraceOpt_hiding_prefix(TraceOpt_ptr arg1) -> char const *"""
    return _trace.TraceOpt_hiding_prefix(arg1)

def TraceOpt_set_hiding_prefix(arg1: 'TraceOpt_ptr', hiding_prefix: 'char const *') -> "void":
    """TraceOpt_set_hiding_prefix(TraceOpt_ptr arg1, char const * hiding_prefix)"""
    return _trace.TraceOpt_set_hiding_prefix(arg1, hiding_prefix)

def TraceOpt_from_here(arg1: 'TraceOpt_ptr') -> "unsigned int":
    """TraceOpt_from_here(TraceOpt_ptr arg1) -> unsigned int"""
    return _trace.TraceOpt_from_here(arg1)

def TraceOpt_set_from_here(arg1: 'TraceOpt_ptr', index: 'unsigned int') -> "void":
    """TraceOpt_set_from_here(TraceOpt_ptr arg1, unsigned int index)"""
    return _trace.TraceOpt_set_from_here(arg1, index)

def TraceOpt_to_here(arg1: 'TraceOpt_ptr') -> "unsigned int":
    """TraceOpt_to_here(TraceOpt_ptr arg1) -> unsigned int"""
    return _trace.TraceOpt_to_here(arg1)

def TraceOpt_set_to_here(arg1: 'TraceOpt_ptr', index: 'unsigned int') -> "void":
    """TraceOpt_set_to_here(TraceOpt_ptr arg1, unsigned int index)"""
    return _trace.TraceOpt_set_to_here(arg1, index)

def TraceOpt_output_stream(arg1: 'TraceOpt_ptr') -> "FILE *":
    """TraceOpt_output_stream(TraceOpt_ptr arg1) -> FILE *"""
    return _trace.TraceOpt_output_stream(arg1)

def TraceOpt_set_output_stream(arg1: 'TraceOpt_ptr', out: 'FILE *') -> "void":
    """TraceOpt_set_output_stream(TraceOpt_ptr arg1, FILE * out)"""
    return _trace.TraceOpt_set_output_stream(arg1, out)
TRACE_XML_INVALID_TAG = _trace.TRACE_XML_INVALID_TAG
TRACE_XML_CNTX_TAG = _trace.TRACE_XML_CNTX_TAG
TRACE_XML_NODE_TAG = _trace.TRACE_XML_NODE_TAG
TRACE_XML_STATE_TAG = _trace.TRACE_XML_STATE_TAG
TRACE_XML_COMB_TAG = _trace.TRACE_XML_COMB_TAG
TRACE_XML_INPUT_TAG = _trace.TRACE_XML_INPUT_TAG
TRACE_XML_VALUE_TAG = _trace.TRACE_XML_VALUE_TAG
TRACE_XML_LOOPS_TAG = _trace.TRACE_XML_LOOPS_TAG
TRACE_XML_CNTX_TAG_STRING = _trace.TRACE_XML_CNTX_TAG_STRING
TRACE_XML_NODE_TAG_STRING = _trace.TRACE_XML_NODE_TAG_STRING
TRACE_XML_STATE_TAG_STRING = _trace.TRACE_XML_STATE_TAG_STRING
TRACE_XML_COMB_TAG_STRING = _trace.TRACE_XML_COMB_TAG_STRING
TRACE_XML_INPUT_TAG_STRING = _trace.TRACE_XML_INPUT_TAG_STRING
TRACE_XML_VALUE_TAG_STRING = _trace.TRACE_XML_VALUE_TAG_STRING
TRACE_XML_LOOPS_TAG_STRING = _trace.TRACE_XML_LOOPS_TAG_STRING

def TraceXmlTag_from_string(tag: 'char const *') -> "TraceXmlTag":
    """TraceXmlTag_from_string(char const * tag) -> TraceXmlTag"""
    return _trace.TraceXmlTag_from_string(tag)

def TraceXmlTag_to_string(tag: 'TraceXmlTag') -> "char const *":
    """TraceXmlTag_to_string(TraceXmlTag tag) -> char const *"""
    return _trace.TraceXmlTag_to_string(tag)

def Trace_concatenate(arg1: 'Trace_ptr', other: 'Trace_ptr') -> "Trace_ptr":
    """Trace_concatenate(Trace_ptr arg1, Trace_ptr other) -> Trace_ptr"""
    return _trace.Trace_concatenate(arg1, other)
class assignment_t(_object):
    """Proxy of C assignment_t struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, assignment_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, assignment_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["symbol"] = _trace.assignment_t_symbol_set
    __swig_getmethods__["symbol"] = _trace.assignment_t_symbol_get
    if _newclass:
        symbol = _swig_property(_trace.assignment_t_symbol_get, _trace.assignment_t_symbol_set)
    __swig_setmethods__["value"] = _trace.assignment_t_value_set
    __swig_getmethods__["value"] = _trace.assignment_t_value_get
    if _newclass:
        value = _swig_property(_trace.assignment_t_value_get, _trace.assignment_t_value_set)
    __swig_setmethods__["success"] = _trace.assignment_t_success_set
    __swig_getmethods__["success"] = _trace.assignment_t_success_get
    if _newclass:
        success = _swig_property(_trace.assignment_t_success_get, _trace.assignment_t_success_set)
    __swig_setmethods__["iter"] = _trace.assignment_t_iter_set
    __swig_getmethods__["iter"] = _trace.assignment_t_iter_get
    if _newclass:
        iter = _swig_property(_trace.assignment_t_iter_get, _trace.assignment_t_iter_set)

    def __init__(self):
        """__init__(assignment_t self) -> assignment_t"""
        this = _trace.new_assignment_t()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _trace.delete_assignment_t
    __del__ = lambda self: None
assignment_t_swigregister = _trace.assignment_t_swigregister
assignment_t_swigregister(assignment_t)


def Trace_step_get_assignment(step_iter: 'TraceStepIter') -> "assignment_t":
    """Trace_step_get_assignment(TraceStepIter step_iter) -> assignment_t"""
    return _trace.Trace_step_get_assignment(step_iter)
# This file is compatible with both classic and new-style classes.


