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

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

def Object_copy(arg1: 'Object_ptr const') -> "Object_ptr":
    """Object_copy(Object_ptr const arg1) -> Object_ptr"""
    return _sexp.Object_copy(arg1)

def BoolSexpFsm_create(hierarchy: 'FlatHierarchy_ptr const', vars_set: 'Set_t const', benc: 'BddEnc_ptr', det_layer: 'SymbLayer_ptr') -> "BoolSexpFsm_ptr":
    """BoolSexpFsm_create(FlatHierarchy_ptr const hierarchy, Set_t const vars_set, BddEnc_ptr benc, SymbLayer_ptr det_layer) -> BoolSexpFsm_ptr"""
    return _sexp.BoolSexpFsm_create(hierarchy, vars_set, benc, det_layer)

def BoolSexpFsm_create_from_scalar_fsm(scalar_fsm: 'SexpFsm_ptr const', benc: 'BddEnc_ptr', det_layer: 'SymbLayer_ptr') -> "BoolSexpFsm_ptr":
    """BoolSexpFsm_create_from_scalar_fsm(SexpFsm_ptr const scalar_fsm, BddEnc_ptr benc, SymbLayer_ptr det_layer) -> BoolSexpFsm_ptr"""
    return _sexp.BoolSexpFsm_create_from_scalar_fsm(scalar_fsm, benc, det_layer)

def BoolSexpFsm_destroy(arg1: 'BoolSexpFsm_ptr') -> "void":
    """BoolSexpFsm_destroy(BoolSexpFsm_ptr arg1)"""
    return _sexp.BoolSexpFsm_destroy(arg1)

def BoolSexpFsm_get_bool_enc(arg1: 'BoolSexpFsm_ptr const') -> "BoolEnc_ptr":
    """BoolSexpFsm_get_bool_enc(BoolSexpFsm_ptr const arg1) -> BoolEnc_ptr"""
    return _sexp.BoolSexpFsm_get_bool_enc(arg1)

def BoolSexpFsm_copy(arg1: 'BoolSexpFsm_ptr') -> "BoolSexpFsm_ptr":
    """BoolSexpFsm_copy(BoolSexpFsm_ptr arg1) -> BoolSexpFsm_ptr"""
    return _sexp.BoolSexpFsm_copy(arg1)

def Expr_true() -> "Expr_ptr":
    """Expr_true() -> Expr_ptr"""
    return _sexp.Expr_true()

def Expr_false() -> "Expr_ptr":
    """Expr_false() -> Expr_ptr"""
    return _sexp.Expr_false()

def Expr_is_true(expr: 'Expr_ptr const') -> "boolean":
    """Expr_is_true(Expr_ptr const expr) -> boolean"""
    return _sexp.Expr_is_true(expr)

def Expr_is_false(expr: 'Expr_ptr const') -> "boolean":
    """Expr_is_false(Expr_ptr const expr) -> boolean"""
    return _sexp.Expr_is_false(expr)

def Expr_next(a: 'Expr_ptr const', st: 'SymbTable_ptr const') -> "Expr_ptr":
    """Expr_next(Expr_ptr const a, SymbTable_ptr const st) -> Expr_ptr"""
    return _sexp.Expr_next(a, st)

def Expr_ite(cond: 'Expr_ptr const', t: 'Expr_ptr const', e: 'Expr_ptr const', st: 'SymbTable_ptr const') -> "Expr_ptr":
    """Expr_ite(Expr_ptr const cond, Expr_ptr const t, Expr_ptr const e, SymbTable_ptr const st) -> Expr_ptr"""
    return _sexp.Expr_ite(cond, t, e, st)

def Expr_equal(a: 'Expr_ptr const', b: 'Expr_ptr const', st: 'SymbTable_ptr const') -> "Expr_ptr":
    """Expr_equal(Expr_ptr const a, Expr_ptr const b, SymbTable_ptr const st) -> Expr_ptr"""
    return _sexp.Expr_equal(a, b, st)

def Expr_notequal(a: 'Expr_ptr const', b: 'Expr_ptr const', st: 'SymbTable_ptr const') -> "Expr_ptr":
    """Expr_notequal(Expr_ptr const a, Expr_ptr const b, SymbTable_ptr const st) -> Expr_ptr"""
    return _sexp.Expr_notequal(a, b, st)

def Expr_le(a: 'Expr_ptr const', b: 'Expr_ptr const', st: 'SymbTable_ptr const') -> "Expr_ptr":
    """Expr_le(Expr_ptr const a, Expr_ptr const b, SymbTable_ptr const st) -> Expr_ptr"""
    return _sexp.Expr_le(a, b, st)

def Expr_ge(a: 'Expr_ptr const', b: 'Expr_ptr const', st: 'SymbTable_ptr const') -> "Expr_ptr":
    """Expr_ge(Expr_ptr const a, Expr_ptr const b, SymbTable_ptr const st) -> Expr_ptr"""
    return _sexp.Expr_ge(a, b, st)

def Expr_simplify_word_extend(st: 'SymbTable_ptr const', w: 'Expr_ptr', i: 'Expr_ptr') -> "Expr_ptr":
    """Expr_simplify_word_extend(SymbTable_ptr const st, Expr_ptr w, Expr_ptr i) -> Expr_ptr"""
    return _sexp.Expr_simplify_word_extend(st, w, i)

def Expr_attime(e: 'Expr_ptr', time: 'int', st: 'SymbTable_ptr const') -> "Expr_ptr":
    """Expr_attime(Expr_ptr e, int time, SymbTable_ptr const st) -> Expr_ptr"""
    return _sexp.Expr_attime(e, time, st)

def Expr_word_constant(st: 'SymbTable_ptr const', type: 'int', w: 'Expr_ptr', i: 'Expr_ptr') -> "Expr_ptr":
    """Expr_word_constant(SymbTable_ptr const st, int type, Expr_ptr w, Expr_ptr i) -> Expr_ptr"""
    return _sexp.Expr_word_constant(st, type, w, i)

def Expr_and_from_list(list: 'node_ptr', st: 'SymbTable_ptr const') -> "Expr_ptr":
    """Expr_and_from_list(node_ptr list, SymbTable_ptr const st) -> Expr_ptr"""
    return _sexp.Expr_and_from_list(list, st)

def Expr_and(a: 'Expr_ptr const', b: 'Expr_ptr const') -> "Expr_ptr":
    """Expr_and(Expr_ptr const a, Expr_ptr const b) -> Expr_ptr"""
    return _sexp.Expr_and(a, b)

def Expr_and_nil(a: 'Expr_ptr const', b: 'Expr_ptr const') -> "Expr_ptr":
    """Expr_and_nil(Expr_ptr const a, Expr_ptr const b) -> Expr_ptr"""
    return _sexp.Expr_and_nil(a, b)

def Expr_not(expr: 'Expr_ptr const') -> "Expr_ptr":
    """Expr_not(Expr_ptr const expr) -> Expr_ptr"""
    return _sexp.Expr_not(expr)

def Expr_or(a: 'Expr_ptr const', b: 'Expr_ptr const') -> "Expr_ptr":
    """Expr_or(Expr_ptr const a, Expr_ptr const b) -> Expr_ptr"""
    return _sexp.Expr_or(a, b)

def Expr_xor(a: 'Expr_ptr const', b: 'Expr_ptr const') -> "Expr_ptr":
    """Expr_xor(Expr_ptr const a, Expr_ptr const b) -> Expr_ptr"""
    return _sexp.Expr_xor(a, b)

def Expr_xnor(a: 'Expr_ptr const', b: 'Expr_ptr const') -> "Expr_ptr":
    """Expr_xnor(Expr_ptr const a, Expr_ptr const b) -> Expr_ptr"""
    return _sexp.Expr_xnor(a, b)

def Expr_iff(a: 'Expr_ptr const', b: 'Expr_ptr const') -> "Expr_ptr":
    """Expr_iff(Expr_ptr const a, Expr_ptr const b) -> Expr_ptr"""
    return _sexp.Expr_iff(a, b)

def Expr_implies(a: 'Expr_ptr const', b: 'Expr_ptr const') -> "Expr_ptr":
    """Expr_implies(Expr_ptr const a, Expr_ptr const b) -> Expr_ptr"""
    return _sexp.Expr_implies(a, b)

def Expr_lt(a: 'Expr_ptr const', b: 'Expr_ptr const') -> "Expr_ptr":
    """Expr_lt(Expr_ptr const a, Expr_ptr const b) -> Expr_ptr"""
    return _sexp.Expr_lt(a, b)

def Expr_simplify_lt(st: 'SymbTable_ptr const', a: 'Expr_ptr const', b: 'Expr_ptr const') -> "Expr_ptr":
    """Expr_simplify_lt(SymbTable_ptr const st, Expr_ptr const a, Expr_ptr const b) -> Expr_ptr"""
    return _sexp.Expr_simplify_lt(st, a, b)

def Expr_gt(a: 'Expr_ptr const', b: 'Expr_ptr const') -> "Expr_ptr":
    """Expr_gt(Expr_ptr const a, Expr_ptr const b) -> Expr_ptr"""
    return _sexp.Expr_gt(a, b)

def Expr_simplify_gt(st: 'SymbTable_ptr const', a: 'Expr_ptr const', b: 'Expr_ptr const') -> "Expr_ptr":
    """Expr_simplify_gt(SymbTable_ptr const st, Expr_ptr const a, Expr_ptr const b) -> Expr_ptr"""
    return _sexp.Expr_simplify_gt(st, a, b)

def Expr_plus(a: 'Expr_ptr const', b: 'Expr_ptr const') -> "Expr_ptr":
    """Expr_plus(Expr_ptr const a, Expr_ptr const b) -> Expr_ptr"""
    return _sexp.Expr_plus(a, b)

def Expr_minus(a: 'Expr_ptr const', b: 'Expr_ptr const') -> "Expr_ptr":
    """Expr_minus(Expr_ptr const a, Expr_ptr const b) -> Expr_ptr"""
    return _sexp.Expr_minus(a, b)

def Expr_times(a: 'Expr_ptr const', b: 'Expr_ptr const') -> "Expr_ptr":
    """Expr_times(Expr_ptr const a, Expr_ptr const b) -> Expr_ptr"""
    return _sexp.Expr_times(a, b)

def Expr_divide(a: 'Expr_ptr const', b: 'Expr_ptr const') -> "Expr_ptr":
    """Expr_divide(Expr_ptr const a, Expr_ptr const b) -> Expr_ptr"""
    return _sexp.Expr_divide(a, b)

def Expr_mod(a: 'Expr_ptr const', b: 'Expr_ptr const') -> "Expr_ptr":
    """Expr_mod(Expr_ptr const a, Expr_ptr const b) -> Expr_ptr"""
    return _sexp.Expr_mod(a, b)

def Expr_unary_minus(a: 'Expr_ptr const') -> "Expr_ptr":
    """Expr_unary_minus(Expr_ptr const a) -> Expr_ptr"""
    return _sexp.Expr_unary_minus(a)

def Expr_word_left_shift(a: 'Expr_ptr const', b: 'Expr_ptr const') -> "Expr_ptr":
    """Expr_word_left_shift(Expr_ptr const a, Expr_ptr const b) -> Expr_ptr"""
    return _sexp.Expr_word_left_shift(a, b)

def Expr_word_right_shift(a: 'Expr_ptr const', b: 'Expr_ptr const') -> "Expr_ptr":
    """Expr_word_right_shift(Expr_ptr const a, Expr_ptr const b) -> Expr_ptr"""
    return _sexp.Expr_word_right_shift(a, b)

def Expr_word_left_rotate(a: 'Expr_ptr const', b: 'Expr_ptr const') -> "Expr_ptr":
    """Expr_word_left_rotate(Expr_ptr const a, Expr_ptr const b) -> Expr_ptr"""
    return _sexp.Expr_word_left_rotate(a, b)

def Expr_word_right_rotate(a: 'Expr_ptr const', b: 'Expr_ptr const') -> "Expr_ptr":
    """Expr_word_right_rotate(Expr_ptr const a, Expr_ptr const b) -> Expr_ptr"""
    return _sexp.Expr_word_right_rotate(a, b)

def Expr_word_bit_select(w: 'Expr_ptr const', r: 'Expr_ptr const') -> "Expr_ptr":
    """Expr_word_bit_select(Expr_ptr const w, Expr_ptr const r) -> Expr_ptr"""
    return _sexp.Expr_word_bit_select(w, r)

def Expr_simplify_word_bit_select(st: 'SymbTable_ptr const', w: 'Expr_ptr const', r: 'Expr_ptr const') -> "Expr_ptr":
    """Expr_simplify_word_bit_select(SymbTable_ptr const st, Expr_ptr const w, Expr_ptr const r) -> Expr_ptr"""
    return _sexp.Expr_simplify_word_bit_select(st, w, r)

def Expr_word_concatenate(a: 'Expr_ptr const', b: 'Expr_ptr const') -> "Expr_ptr":
    """Expr_word_concatenate(Expr_ptr const a, Expr_ptr const b) -> Expr_ptr"""
    return _sexp.Expr_word_concatenate(a, b)

def Expr_word1_to_bool(w: 'Expr_ptr') -> "Expr_ptr":
    """Expr_word1_to_bool(Expr_ptr w) -> Expr_ptr"""
    return _sexp.Expr_word1_to_bool(w)

def Expr_bool_to_word1(a: 'Expr_ptr') -> "Expr_ptr":
    """Expr_bool_to_word1(Expr_ptr a) -> Expr_ptr"""
    return _sexp.Expr_bool_to_word1(a)

def Expr_signed_word_to_unsigned(w: 'Expr_ptr') -> "Expr_ptr":
    """Expr_signed_word_to_unsigned(Expr_ptr w) -> Expr_ptr"""
    return _sexp.Expr_signed_word_to_unsigned(w)

def Expr_unsigned_word_to_signed(w: 'Expr_ptr') -> "Expr_ptr":
    """Expr_unsigned_word_to_signed(Expr_ptr w) -> Expr_ptr"""
    return _sexp.Expr_unsigned_word_to_signed(w)

def Expr_word_extend(w: 'Expr_ptr', i: 'Expr_ptr', st: 'SymbTable_ptr const') -> "Expr_ptr":
    """Expr_word_extend(Expr_ptr w, Expr_ptr i, SymbTable_ptr const st) -> Expr_ptr"""
    return _sexp.Expr_word_extend(w, i, st)

def Expr_attime_get_time(e: 'Expr_ptr') -> "int":
    """Expr_attime_get_time(Expr_ptr e) -> int"""
    return _sexp.Expr_attime_get_time(e)

def Expr_attime_get_untimed(e: 'Expr_ptr') -> "Expr_ptr":
    """Expr_attime_get_untimed(Expr_ptr e) -> Expr_ptr"""
    return _sexp.Expr_attime_get_untimed(e)

def Expr_union(a: 'Expr_ptr const', b: 'Expr_ptr const') -> "Expr_ptr":
    """Expr_union(Expr_ptr const a, Expr_ptr const b) -> Expr_ptr"""
    return _sexp.Expr_union(a, b)

def Expr_setin(a: 'Expr_ptr const', b: 'Expr_ptr const', st: 'SymbTable_ptr const') -> "Expr_ptr":
    """Expr_setin(Expr_ptr const a, Expr_ptr const b, SymbTable_ptr const st) -> Expr_ptr"""
    return _sexp.Expr_setin(a, b, st)

def Expr_range(a: 'Expr_ptr const', b: 'Expr_ptr const') -> "Expr_ptr":
    """Expr_range(Expr_ptr const a, Expr_ptr const b) -> Expr_ptr"""
    return _sexp.Expr_range(a, b)

def Expr_function(name: 'Expr_ptr const', params: 'Expr_ptr const') -> "Expr_ptr":
    """Expr_function(Expr_ptr const name, Expr_ptr const params) -> Expr_ptr"""
    return _sexp.Expr_function(name, params)

def Expr_resolve(st: 'SymbTable_ptr', type: 'int', left: 'Expr_ptr', right: 'Expr_ptr') -> "Expr_ptr":
    """Expr_resolve(SymbTable_ptr st, int type, Expr_ptr left, Expr_ptr right) -> Expr_ptr"""
    return _sexp.Expr_resolve(st, type, left, right)

def Expr_simplify(st: 'SymbTable_ptr', expr: 'Expr_ptr') -> "Expr_ptr":
    """Expr_simplify(SymbTable_ptr st, Expr_ptr expr) -> Expr_ptr"""
    return _sexp.Expr_simplify(st, expr)

def Expr_is_timed(expr: 'Expr_ptr', cache: 'hash_ptr') -> "boolean":
    """Expr_is_timed(Expr_ptr expr, hash_ptr cache) -> boolean"""
    return _sexp.Expr_is_timed(expr, cache)

def Expr_get_time(st: 'SymbTable_ptr', expr: 'Expr_ptr') -> "int":
    """Expr_get_time(SymbTable_ptr st, Expr_ptr expr) -> int"""
    return _sexp.Expr_get_time(st, expr)

def Expr_untimed(st: 'SymbTable_ptr', expr: 'Expr_ptr') -> "Expr_ptr":
    """Expr_untimed(SymbTable_ptr st, Expr_ptr expr) -> Expr_ptr"""
    return _sexp.Expr_untimed(st, expr)

def Expr_untimed_explicit_time(st: 'SymbTable_ptr', expr: 'Expr_ptr', time: 'int') -> "Expr_ptr":
    """Expr_untimed_explicit_time(SymbTable_ptr st, Expr_ptr expr, int time) -> Expr_ptr"""
    return _sexp.Expr_untimed_explicit_time(st, expr, time)

def Expr_wsizeof(l: 'Expr_ptr', r: 'Expr_ptr') -> "Expr_ptr":
    """Expr_wsizeof(Expr_ptr l, Expr_ptr r) -> Expr_ptr"""
    return _sexp.Expr_wsizeof(l, r)

def Expr_cast_toint(l: 'Expr_ptr', r: 'Expr_ptr') -> "Expr_ptr":
    """Expr_cast_toint(Expr_ptr l, Expr_ptr r) -> Expr_ptr"""
    return _sexp.Expr_cast_toint(l, r)

def SexpFsm_create(hierarchy: 'FlatHierarchy_ptr const', vars_set: 'Set_t const') -> "SexpFsm_ptr":
    """SexpFsm_create(FlatHierarchy_ptr const hierarchy, Set_t const vars_set) -> SexpFsm_ptr"""
    return _sexp.SexpFsm_create(hierarchy, vars_set)

def SexpFsm_copy(arg1: 'SexpFsm_ptr const') -> "SexpFsm_ptr":
    """SexpFsm_copy(SexpFsm_ptr const arg1) -> SexpFsm_ptr"""
    return _sexp.SexpFsm_copy(arg1)

def SexpFsm_create_predicate_normalised_copy(arg1: 'SexpFsm_ptr const', normaliser: 'PredicateNormaliser_ptr') -> "SexpFsm_ptr":
    """SexpFsm_create_predicate_normalised_copy(SexpFsm_ptr const arg1, PredicateNormaliser_ptr normaliser) -> SexpFsm_ptr"""
    return _sexp.SexpFsm_create_predicate_normalised_copy(arg1, normaliser)

def SexpFsm_destroy(arg1: 'SexpFsm_ptr') -> "void":
    """SexpFsm_destroy(SexpFsm_ptr arg1)"""
    return _sexp.SexpFsm_destroy(arg1)

def SexpFsm_get_symb_table(arg1: 'SexpFsm_ptr const') -> "SymbTable_ptr":
    """SexpFsm_get_symb_table(SexpFsm_ptr const arg1) -> SymbTable_ptr"""
    return _sexp.SexpFsm_get_symb_table(arg1)

def SexpFsm_is_boolean(arg1: 'SexpFsm_ptr const') -> "boolean":
    """SexpFsm_is_boolean(SexpFsm_ptr const arg1) -> boolean"""
    return _sexp.SexpFsm_is_boolean(arg1)

def SexpFsm_get_hierarchy(arg1: 'SexpFsm_ptr const') -> "FlatHierarchy_ptr":
    """SexpFsm_get_hierarchy(SexpFsm_ptr const arg1) -> FlatHierarchy_ptr"""
    return _sexp.SexpFsm_get_hierarchy(arg1)

def SexpFsm_get_init(arg1: 'SexpFsm_ptr const') -> "Expr_ptr":
    """SexpFsm_get_init(SexpFsm_ptr const arg1) -> Expr_ptr"""
    return _sexp.SexpFsm_get_init(arg1)

def SexpFsm_get_invar(arg1: 'SexpFsm_ptr const') -> "Expr_ptr":
    """SexpFsm_get_invar(SexpFsm_ptr const arg1) -> Expr_ptr"""
    return _sexp.SexpFsm_get_invar(arg1)

def SexpFsm_get_trans(arg1: 'SexpFsm_ptr const') -> "Expr_ptr":
    """SexpFsm_get_trans(SexpFsm_ptr const arg1) -> Expr_ptr"""
    return _sexp.SexpFsm_get_trans(arg1)

def SexpFsm_get_input(arg1: 'SexpFsm_ptr const') -> "Expr_ptr":
    """SexpFsm_get_input(SexpFsm_ptr const arg1) -> Expr_ptr"""
    return _sexp.SexpFsm_get_input(arg1)

def SexpFsm_get_justice(arg1: 'SexpFsm_ptr const') -> "node_ptr":
    """SexpFsm_get_justice(SexpFsm_ptr const arg1) -> node_ptr"""
    return _sexp.SexpFsm_get_justice(arg1)

def SexpFsm_get_compassion(arg1: 'SexpFsm_ptr const') -> "node_ptr":
    """SexpFsm_get_compassion(SexpFsm_ptr const arg1) -> node_ptr"""
    return _sexp.SexpFsm_get_compassion(arg1)

def SexpFsm_get_vars_list(arg1: 'SexpFsm_ptr const') -> "NodeList_ptr":
    """SexpFsm_get_vars_list(SexpFsm_ptr const arg1) -> NodeList_ptr"""
    return _sexp.SexpFsm_get_vars_list(arg1)

def SexpFsm_get_symbols_list(arg1: 'SexpFsm_ptr const') -> "NodeList_ptr":
    """SexpFsm_get_symbols_list(SexpFsm_ptr const arg1) -> NodeList_ptr"""
    return _sexp.SexpFsm_get_symbols_list(arg1)

def SexpFsm_get_vars(arg1: 'SexpFsm_ptr const') -> "Set_t":
    """SexpFsm_get_vars(SexpFsm_ptr const arg1) -> Set_t"""
    return _sexp.SexpFsm_get_vars(arg1)

def SexpFsm_apply_synchronous_product(arg1: 'SexpFsm_ptr', other: 'SexpFsm_ptr') -> "void":
    """SexpFsm_apply_synchronous_product(SexpFsm_ptr arg1, SexpFsm_ptr other)"""
    return _sexp.SexpFsm_apply_synchronous_product(arg1, other)

def SexpFsm_is_syntactically_universal(arg1: 'SexpFsm_ptr') -> "boolean":
    """SexpFsm_is_syntactically_universal(SexpFsm_ptr arg1) -> boolean"""
    return _sexp.SexpFsm_is_syntactically_universal(arg1)

def SexpFsm_get_var_init(arg1: 'SexpFsm_ptr const', v: 'node_ptr') -> "Expr_ptr":
    """SexpFsm_get_var_init(SexpFsm_ptr const arg1, node_ptr v) -> Expr_ptr"""
    return _sexp.SexpFsm_get_var_init(arg1, v)

def SexpFsm_get_var_invar(arg1: 'SexpFsm_ptr const', v: 'node_ptr') -> "Expr_ptr":
    """SexpFsm_get_var_invar(SexpFsm_ptr const arg1, node_ptr v) -> Expr_ptr"""
    return _sexp.SexpFsm_get_var_invar(arg1, v)

def SexpFsm_get_var_trans(arg1: 'SexpFsm_ptr const', v: 'node_ptr') -> "Expr_ptr":
    """SexpFsm_get_var_trans(SexpFsm_ptr const arg1, node_ptr v) -> Expr_ptr"""
    return _sexp.SexpFsm_get_var_trans(arg1, v)

def SexpFsm_get_var_input(arg1: 'SexpFsm_ptr const', v: 'node_ptr') -> "Expr_ptr":
    """SexpFsm_get_var_input(SexpFsm_ptr const arg1, node_ptr v) -> Expr_ptr"""
    return _sexp.SexpFsm_get_var_input(arg1, v)

def SexpFsm_self_check(arg1: 'SexpFsm_ptr const') -> "void":
    """SexpFsm_self_check(SexpFsm_ptr const arg1)"""
    return _sexp.SexpFsm_self_check(arg1)

def boolsexpfsm_to_sexpfsm(ptr: 'BoolSexpFsm_ptr') -> "SexpFsm_ptr":
    """boolsexpfsm_to_sexpfsm(BoolSexpFsm_ptr ptr) -> SexpFsm_ptr"""
    return _sexp.boolsexpfsm_to_sexpfsm(ptr)
# This file is compatible with both classic and new-style classes.


