# 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, '_psl')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_psl')
    _psl = 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('_psl', [dirname(__file__)])
        except ImportError:
            import _psl
            return _psl
        if fp is not None:
            try:
                _mod = imp.load_module('_psl', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _psl = swig_import_helper()
    del swig_import_helper
else:
    import _psl
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 = _psl.PRIuPTR
PRIdPTR = _psl.PRIdPTR
LLU = _psl.LLU
LLO = _psl.LLO
LLX = _psl.LLX
false = _psl.false
true = _psl.true
OUTCOME_GENERIC_ERROR = _psl.OUTCOME_GENERIC_ERROR
OUTCOME_PARSER_ERROR = _psl.OUTCOME_PARSER_ERROR
OUTCOME_SYNTAX_ERROR = _psl.OUTCOME_SYNTAX_ERROR
OUTCOME_FILE_ERROR = _psl.OUTCOME_FILE_ERROR
OUTCOME_SUCCESS_REQUIRED_HELP = _psl.OUTCOME_SUCCESS_REQUIRED_HELP
OUTCOME_SUCCESS = _psl.OUTCOME_SUCCESS
SC_NUM_EXPR = _psl.SC_NUM_EXPR
SC_BOOL_EXPR = _psl.SC_BOOL_EXPR
SC_WORD_EXPR = _psl.SC_WORD_EXPR
SC_IDENTIFIER = _psl.SC_IDENTIFIER
SC_NUM_BOOL_WORD_EXPR = _psl.SC_NUM_BOOL_WORD_EXPR
SC_NUM_BOOL_EXPR = _psl.SC_NUM_BOOL_EXPR
SC_BOOL_WORD_EXPR = _psl.SC_BOOL_WORD_EXPR
SC_NUM_WORD_EXPR = _psl.SC_NUM_WORD_EXPR
SC_PROPERTY = _psl.SC_PROPERTY
SC_FL_PROPERTY = _psl.SC_FL_PROPERTY
SC_OBE_PROPERTY = _psl.SC_OBE_PROPERTY
SC_SEQUENCE = _psl.SC_SEQUENCE
SC_REPLICATOR = _psl.SC_REPLICATOR
SC_NONE = _psl.SC_NONE
SC_RANGE = _psl.SC_RANGE
SC_LIST = _psl.SC_LIST
SC_NUM_RANGE = _psl.SC_NUM_RANGE
class PslExpr(_object):
    """Proxy of C PslExpr_TAG struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PslExpr, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PslExpr, name)
    __repr__ = _swig_repr
    __swig_setmethods__["klass"] = _psl.PslExpr_klass_set
    __swig_getmethods__["klass"] = _psl.PslExpr_klass_get
    if _newclass:
        klass = _swig_property(_psl.PslExpr_klass_get, _psl.PslExpr_klass_set)
    __swig_setmethods__["psl_node"] = _psl.PslExpr_psl_node_set
    __swig_getmethods__["psl_node"] = _psl.PslExpr_psl_node_get
    if _newclass:
        psl_node = _swig_property(_psl.PslExpr_psl_node_get, _psl.PslExpr_psl_node_set)

    def __init__(self):
        """__init__(PslExpr_TAG self) -> PslExpr"""
        this = _psl.new_PslExpr()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _psl.delete_PslExpr
    __del__ = lambda self: None
PslExpr_swigregister = _psl.PslExpr_swigregister
PslExpr_swigregister(PslExpr)


def psl_expr_make_unary_op(res: 'PslExpr', right: 'PslExpr', op_id: 'PslOp const', right_req_klass: 'SyntaxClass const', res_klass: 'SyntaxClass const') -> "void":
    """psl_expr_make_unary_op(PslExpr res, PslExpr right, PslOp const op_id, SyntaxClass const right_req_klass, SyntaxClass const res_klass)"""
    return _psl.psl_expr_make_unary_op(res, right, op_id, right_req_klass, res_klass)

def psl_expr_make_binary_op(res: 'PslExpr', left: 'PslExpr', op_id: 'PslOp const', right: 'PslExpr', ops_req_klass: 'SyntaxClass const', res_klass: 'SyntaxClass const') -> "void":
    """psl_expr_make_binary_op(PslExpr res, PslExpr left, PslOp const op_id, PslExpr right, SyntaxClass const ops_req_klass, SyntaxClass const res_klass)"""
    return _psl.psl_expr_make_binary_op(res, left, op_id, right, ops_req_klass, res_klass)

def psl_expr_make_binary_mixed_op(res: 'PslExpr', left: 'PslExpr', op_id: 'PslOp const', right: 'PslExpr', left_req_klass: 'SyntaxClass const', right_req_klass: 'SyntaxClass const', res_klass: 'SyntaxClass const') -> "void":
    """psl_expr_make_binary_mixed_op(PslExpr res, PslExpr left, PslOp const op_id, PslExpr right, SyntaxClass const left_req_klass, SyntaxClass const right_req_klass, SyntaxClass const res_klass)"""
    return _psl.psl_expr_make_binary_mixed_op(res, left, op_id, right, left_req_klass, right_req_klass, res_klass)

def psl_expr_make_extended_next_op(op_id: 'PslOp', fl_property: 'PslExpr', when: 'PslExpr', bool_expr: 'PslExpr', res: 'PslExpr') -> "void":
    """psl_expr_make_extended_next_op(PslOp op_id, PslExpr fl_property, PslExpr when, PslExpr bool_expr, PslExpr res)"""
    return _psl.psl_expr_make_extended_next_op(op_id, fl_property, when, bool_expr, res)

def psl_expr_make_replicator(op_id: 'PslOp', id: 'PslExpr', range: 'PslExpr', value_set: 'PslExpr') -> "PslExpr":
    """psl_expr_make_replicator(PslOp op_id, PslExpr id, PslExpr range, PslExpr value_set) -> PslExpr"""
    return _psl.psl_expr_make_replicator(op_id, id, range, value_set)

def psl_expr_make_replicated_property(replicator: 'PslExpr', expr: 'PslExpr') -> "PslExpr":
    """psl_expr_make_replicated_property(PslExpr replicator, PslExpr expr) -> PslExpr"""
    return _psl.psl_expr_make_replicated_property(replicator, expr)

def psl_expr_make_atom(str: 'char const *') -> "PslExpr":
    """psl_expr_make_atom(char const * str) -> PslExpr"""
    return _psl.psl_expr_make_atom(str)

def psl_expr_make_id(left: 'PslExpr', right: 'PslExpr') -> "PslExpr":
    """psl_expr_make_id(PslExpr left, PslExpr right) -> PslExpr"""
    return _psl.psl_expr_make_id(left, right)

def psl_expr_make_id_array(id: 'PslExpr', num: 'PslExpr') -> "PslExpr":
    """psl_expr_make_id_array(PslExpr id, PslExpr num) -> PslExpr"""
    return _psl.psl_expr_make_id_array(id, num)

def psl_expr_make_context(ctx: 'PslExpr', node: 'PslExpr') -> "PslExpr":
    """psl_expr_make_context(PslExpr ctx, PslExpr node) -> PslExpr"""
    return _psl.psl_expr_make_context(ctx, node)

def psl_expr_make_empty() -> "PslExpr":
    """psl_expr_make_empty() -> PslExpr"""
    return _psl.psl_expr_make_empty()

def psl_expr_make_true() -> "PslExpr":
    """psl_expr_make_true() -> PslExpr"""
    return _psl.psl_expr_make_true()

def psl_expr_make_false() -> "PslExpr":
    """psl_expr_make_false() -> PslExpr"""
    return _psl.psl_expr_make_false()

def psl_expr_make_inf() -> "PslExpr":
    """psl_expr_make_inf() -> PslExpr"""
    return _psl.psl_expr_make_inf()

def psl_expr_make_boolean_type() -> "PslExpr":
    """psl_expr_make_boolean_type() -> PslExpr"""
    return _psl.psl_expr_make_boolean_type()

def psl_expr_make_boolean_value(val: 'int') -> "PslExpr":
    """psl_expr_make_boolean_value(int val) -> PslExpr"""
    return _psl.psl_expr_make_boolean_value(val)

def psl_expr_make_failure(msg: 'char const *', kind: 'FailureKind') -> "PslExpr":
    """psl_expr_make_failure(char const * msg, FailureKind kind) -> PslExpr"""
    return _psl.psl_expr_make_failure(msg, kind)

def psl_expr_make_number(val: 'int') -> "PslExpr":
    """psl_expr_make_number(int val) -> PslExpr"""
    return _psl.psl_expr_make_number(val)

def psl_expr_make_base_number(base_num: 'char *') -> "PslExpr":
    """psl_expr_make_base_number(char * base_num) -> PslExpr"""
    return _psl.psl_expr_make_base_number(base_num)

def psl_expr_make_real_number(fval: 'char *') -> "PslExpr":
    """psl_expr_make_real_number(char * fval) -> PslExpr"""
    return _psl.psl_expr_make_real_number(fval)

def psl_expr_make_word_number(wval: 'char *') -> "PslExpr":
    """psl_expr_make_word_number(char * wval) -> PslExpr"""
    return _psl.psl_expr_make_word_number(wval)

def psl_expr_make_range(low: 'PslExpr', high: 'PslExpr') -> "PslExpr":
    """psl_expr_make_range(PslExpr low, PslExpr high) -> PslExpr"""
    return _psl.psl_expr_make_range(low, high)

def psl_expr_make_case(cond: 'PslExpr', _then: 'PslExpr', _list: 'PslExpr') -> "PslExpr":
    """psl_expr_make_case(PslExpr cond, PslExpr _then, PslExpr _list) -> PslExpr"""
    return _psl.psl_expr_make_case(cond, _then, _list)

def psl_expr_make_ite(cond: 'PslExpr', _then: 'PslExpr', _else: 'PslExpr') -> "PslExpr":
    """psl_expr_make_ite(PslExpr cond, PslExpr _then, PslExpr _else) -> PslExpr"""
    return _psl.psl_expr_make_ite(cond, _then, _else)

def psl_expr_make_suffix_implication_weak(seq: 'PslExpr', op: 'PslOp', expr: 'PslExpr') -> "PslExpr":
    """psl_expr_make_suffix_implication_weak(PslExpr seq, PslOp op, PslExpr expr) -> PslExpr"""
    return _psl.psl_expr_make_suffix_implication_weak(seq, op, expr)

def psl_expr_make_suffix_implication_strong(seq: 'PslExpr', op: 'PslOp', expr: 'PslExpr') -> "PslExpr":
    """psl_expr_make_suffix_implication_strong(PslExpr seq, PslOp op, PslExpr expr) -> PslExpr"""
    return _psl.psl_expr_make_suffix_implication_strong(seq, op, expr)

def psl_expr_make_within(op: 'PslOp', begin: 'PslExpr', end: 'PslExpr', seq: 'PslExpr') -> "PslExpr":
    """psl_expr_make_within(PslOp op, PslExpr begin, PslExpr end, PslExpr seq) -> PslExpr"""
    return _psl.psl_expr_make_within(op, begin, end, seq)

def psl_expr_make_whilenot(op: 'PslOp', expr: 'PslExpr', seq: 'PslExpr') -> "PslExpr":
    """psl_expr_make_whilenot(PslOp op, PslExpr expr, PslExpr seq) -> PslExpr"""
    return _psl.psl_expr_make_whilenot(op, expr, seq)

def psl_expr_make_abort(fl_prop: 'PslExpr', cond: 'PslExpr') -> "PslExpr":
    """psl_expr_make_abort(PslExpr fl_prop, PslExpr cond) -> PslExpr"""
    return _psl.psl_expr_make_abort(fl_prop, cond)

def psl_expr_make_sere(expr: 'PslExpr') -> "PslExpr":
    """psl_expr_make_sere(PslExpr expr) -> PslExpr"""
    return _psl.psl_expr_make_sere(expr)

def psl_expr_make_sere_concat(seq1: 'PslExpr', seq2: 'PslExpr') -> "PslExpr":
    """psl_expr_make_sere_concat(PslExpr seq1, PslExpr seq2) -> PslExpr"""
    return _psl.psl_expr_make_sere_concat(seq1, seq2)

def psl_expr_make_sere_fusion(seq1: 'PslExpr', seq2: 'PslExpr') -> "PslExpr":
    """psl_expr_make_sere_fusion(PslExpr seq1, PslExpr seq2) -> PslExpr"""
    return _psl.psl_expr_make_sere_fusion(seq1, seq2)

def psl_expr_make_sere_compound_binary_op(seq1: 'PslExpr', op: 'PslOp', seq2: 'PslExpr') -> "PslExpr":
    """psl_expr_make_sere_compound_binary_op(PslExpr seq1, PslOp op, PslExpr seq2) -> PslExpr"""
    return _psl.psl_expr_make_sere_compound_binary_op(seq1, op, seq2)

def psl_expr_make_repeated_sere(op: 'PslOp', sere: 'PslExpr', count: 'PslExpr') -> "PslExpr":
    """psl_expr_make_repeated_sere(PslOp op, PslExpr sere, PslExpr count) -> PslExpr"""
    return _psl.psl_expr_make_repeated_sere(op, sere, count)

def psl_expr_make_cons(a: 'PslExpr', b: 'PslExpr') -> "PslExpr":
    """psl_expr_make_cons(PslExpr a, PslExpr b) -> PslExpr"""
    return _psl.psl_expr_make_cons(a, b)

def psl_expr_make_cons_new(a: 'PslExpr', b: 'PslExpr') -> "PslExpr":
    """psl_expr_make_cons_new(PslExpr a, PslExpr b) -> PslExpr"""
    return _psl.psl_expr_make_cons_new(a, b)

def psl_expr_make_concatenation(expr_list: 'PslExpr') -> "PslExpr":
    """psl_expr_make_concatenation(PslExpr expr_list) -> PslExpr"""
    return _psl.psl_expr_make_concatenation(expr_list)

def psl_expr_make_multiple_concatenation(expr: 'PslExpr', expr_list: 'PslExpr') -> "PslExpr":
    """psl_expr_make_multiple_concatenation(PslExpr expr, PslExpr expr_list) -> PslExpr"""
    return _psl.psl_expr_make_multiple_concatenation(expr, expr_list)

def psl_expr_make_obe_unary(op: 'PslOp', expr: 'PslExpr') -> "PslExpr":
    """psl_expr_make_obe_unary(PslOp op, PslExpr expr) -> PslExpr"""
    return _psl.psl_expr_make_obe_unary(op, expr)

def psl_expr_make_obe_binary(left: 'PslExpr', op: 'PslOp', right: 'PslExpr') -> "PslExpr":
    """psl_expr_make_obe_binary(PslExpr left, PslOp op, PslExpr right) -> PslExpr"""
    return _psl.psl_expr_make_obe_binary(left, op, right)

def psl_expr_make_bit_selection(word_expr: 'PslExpr', left: 'PslExpr', right: 'PslExpr') -> "PslExpr":
    """psl_expr_make_bit_selection(PslExpr word_expr, PslExpr left, PslExpr right) -> PslExpr"""
    return _psl.psl_expr_make_bit_selection(word_expr, left, right)

def psl_expr_make_word_concatenation(left: 'PslExpr', right: 'PslExpr') -> "PslExpr":
    """psl_expr_make_word_concatenation(PslExpr left, PslExpr right) -> PslExpr"""
    return _psl.psl_expr_make_word_concatenation(left, right)
TOK2PSL = _psl.TOK2PSL
TOK2SMV = _psl.TOK2SMV
PSL2SMV = _psl.PSL2SMV
PSL2PSL = _psl.PSL2PSL
PSL2TOK = _psl.PSL2TOK

def PslNode_convert_psl_to_core(expr: 'PslNode_ptr') -> "node_ptr":
    """PslNode_convert_psl_to_core(PslNode_ptr expr) -> node_ptr"""
    return _psl.PslNode_convert_psl_to_core(expr)

def psl_new_node(op: 'PslOp', left: 'PslNode_ptr', right: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_new_node(PslOp op, PslNode_ptr left, PslNode_ptr right) -> PslNode_ptr"""
    return _psl.psl_new_node(op, left, right)

def psl_node_get_left(n: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_get_left(PslNode_ptr n) -> PslNode_ptr"""
    return _psl.psl_node_get_left(n)

def psl_node_get_right(n: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_get_right(PslNode_ptr n) -> PslNode_ptr"""
    return _psl.psl_node_get_right(n)

def psl_node_get_op(n: 'PslNode_ptr') -> "PslOp":
    """psl_node_get_op(PslNode_ptr n) -> PslOp"""
    return _psl.psl_node_get_op(n)

def psl_node_set_left(n: 'PslNode_ptr', l: 'PslNode_ptr') -> "void":
    """psl_node_set_left(PslNode_ptr n, PslNode_ptr l)"""
    return _psl.psl_node_set_left(n, l)

def psl_node_set_right(n: 'PslNode_ptr', r: 'PslNode_ptr') -> "void":
    """psl_node_set_right(PslNode_ptr n, PslNode_ptr r)"""
    return _psl.psl_node_set_right(n, r)

def PslNode_convert_from_node_ptr(expr: 'node_ptr') -> "PslNode_ptr":
    """PslNode_convert_from_node_ptr(node_ptr expr) -> PslNode_ptr"""
    return _psl.PslNode_convert_from_node_ptr(expr)

def PslNode_convert_to_node_ptr(expr: 'PslNode_ptr') -> "node_ptr":
    """PslNode_convert_to_node_ptr(PslNode_ptr expr) -> node_ptr"""
    return _psl.PslNode_convert_to_node_ptr(expr)

def psl_node_make_true() -> "PslNode_ptr":
    """psl_node_make_true() -> PslNode_ptr"""
    return _psl.psl_node_make_true()

def psl_node_make_false() -> "PslNode_ptr":
    """psl_node_make_false() -> PslNode_ptr"""
    return _psl.psl_node_make_false()

def psl_node_is_true(e: 'PslNode_ptr') -> "boolean":
    """psl_node_is_true(PslNode_ptr e) -> boolean"""
    return _psl.psl_node_is_true(e)

def psl_node_is_false(e: 'PslNode_ptr') -> "boolean":
    """psl_node_is_false(PslNode_ptr e) -> boolean"""
    return _psl.psl_node_is_false(e)

def psl_node_prune(tree: 'PslNode_ptr', branch: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_prune(PslNode_ptr tree, PslNode_ptr branch) -> PslNode_ptr"""
    return _psl.psl_node_prune(tree, branch)

def psl_node_is_sere(expr: 'PslNode_ptr') -> "boolean":
    """psl_node_is_sere(PslNode_ptr expr) -> boolean"""
    return _psl.psl_node_is_sere(expr)

def psl_node_sere_star_get_count(e: 'PslNode_ptr const') -> "PslNode_ptr":
    """psl_node_sere_star_get_count(PslNode_ptr const e) -> PslNode_ptr"""
    return _psl.psl_node_sere_star_get_count(e)

def psl_node_is_handled_star(expr: 'PslNode_ptr', toplevel: 'boolean') -> "boolean":
    """psl_node_is_handled_star(PslNode_ptr expr, boolean toplevel) -> boolean"""
    return _psl.psl_node_is_handled_star(expr, toplevel)

def psl_node_sere_is_propositional(e: 'PslNode_ptr') -> "boolean":
    """psl_node_sere_is_propositional(PslNode_ptr e) -> boolean"""
    return _psl.psl_node_sere_is_propositional(e)

def psl_node_sere_is_repeated(e: 'PslNode_ptr') -> "boolean":
    """psl_node_sere_is_repeated(PslNode_ptr e) -> boolean"""
    return _psl.psl_node_sere_is_repeated(e)

def psl_node_sere_is_star(e: 'PslNode_ptr') -> "boolean":
    """psl_node_sere_is_star(PslNode_ptr e) -> boolean"""
    return _psl.psl_node_sere_is_star(e)

def psl_node_sere_star_get_starred(e: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_sere_star_get_starred(PslNode_ptr e) -> PslNode_ptr"""
    return _psl.psl_node_sere_star_get_starred(e)

def psl_node_sere_is_stareq(e: 'PslNode_ptr') -> "boolean":
    """psl_node_sere_is_stareq(PslNode_ptr e) -> boolean"""
    return _psl.psl_node_sere_is_stareq(e)

def psl_node_sere_is_starminusgt(e: 'PslNode_ptr') -> "boolean":
    """psl_node_sere_is_starminusgt(PslNode_ptr e) -> boolean"""
    return _psl.psl_node_sere_is_starminusgt(e)

def psl_node_sere_is_standalone_star(e: 'PslNode_ptr') -> "boolean":
    """psl_node_sere_is_standalone_star(PslNode_ptr e) -> boolean"""
    return _psl.psl_node_sere_is_standalone_star(e)

def psl_node_sere_is_plus(e: 'PslNode_ptr') -> "boolean":
    """psl_node_sere_is_plus(PslNode_ptr e) -> boolean"""
    return _psl.psl_node_sere_is_plus(e)

def psl_node_sere_is_standalone_plus(e: 'PslNode_ptr') -> "boolean":
    """psl_node_sere_is_standalone_plus(PslNode_ptr e) -> boolean"""
    return _psl.psl_node_sere_is_standalone_plus(e)

def psl_node_sere_is_star_count(e: 'PslNode_ptr') -> "boolean":
    """psl_node_sere_is_star_count(PslNode_ptr e) -> boolean"""
    return _psl.psl_node_sere_is_star_count(e)

def psl_node_sere_is_star_count_zero(e: 'PslNode_ptr') -> "boolean":
    """psl_node_sere_is_star_count_zero(PslNode_ptr e) -> boolean"""
    return _psl.psl_node_sere_is_star_count_zero(e)

def psl_node_sere_is_concat_holes_free(e: 'PslNode_ptr') -> "boolean":
    """psl_node_sere_is_concat_holes_free(PslNode_ptr e) -> boolean"""
    return _psl.psl_node_sere_is_concat_holes_free(e)

def psl_node_sere_is_concat_fusion(e: 'PslNode_ptr') -> "boolean":
    """psl_node_sere_is_concat_fusion(PslNode_ptr e) -> boolean"""
    return _psl.psl_node_sere_is_concat_fusion(e)

def psl_node_sere_is_concat_fusion_holes_free(e: 'PslNode_ptr') -> "boolean":
    """psl_node_sere_is_concat_fusion_holes_free(PslNode_ptr e) -> boolean"""
    return _psl.psl_node_sere_is_concat_fusion_holes_free(e)

def psl_node_sere_is_2ampersand(e: 'PslNode_ptr') -> "boolean":
    """psl_node_sere_is_2ampersand(PslNode_ptr e) -> boolean"""
    return _psl.psl_node_sere_is_2ampersand(e)

def psl_node_is_suffix_implication(expr: 'PslNode_ptr') -> "boolean":
    """psl_node_is_suffix_implication(PslNode_ptr expr) -> boolean"""
    return _psl.psl_node_is_suffix_implication(expr)

def psl_node_is_suffix_implication_weak(expr: 'PslNode_ptr') -> "boolean":
    """psl_node_is_suffix_implication_weak(PslNode_ptr expr) -> boolean"""
    return _psl.psl_node_is_suffix_implication_weak(expr)

def psl_node_is_suffix_implication_strong(expr: 'PslNode_ptr') -> "boolean":
    """psl_node_is_suffix_implication_strong(PslNode_ptr expr) -> boolean"""
    return _psl.psl_node_is_suffix_implication_strong(expr)

def psl_node_is_propstar(e: 'PslNode_ptr') -> "boolean":
    """psl_node_is_propstar(PslNode_ptr e) -> boolean"""
    return _psl.psl_node_is_propstar(e)

def psl_node_is_ite(_ite: 'PslNode_ptr') -> "boolean":
    """psl_node_is_ite(PslNode_ptr _ite) -> boolean"""
    return _psl.psl_node_is_ite(_ite)

def psl_node_get_ite_cond(_ite: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_get_ite_cond(PslNode_ptr _ite) -> PslNode_ptr"""
    return _psl.psl_node_get_ite_cond(_ite)

def psl_node_get_ite_then(_ite: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_get_ite_then(PslNode_ptr _ite) -> PslNode_ptr"""
    return _psl.psl_node_get_ite_then(_ite)

def psl_node_get_ite_else(_ite: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_get_ite_else(PslNode_ptr _ite) -> PslNode_ptr"""
    return _psl.psl_node_get_ite_else(_ite)

def psl_node_is_case(_case: 'PslNode_ptr') -> "boolean":
    """psl_node_is_case(PslNode_ptr _case) -> boolean"""
    return _psl.psl_node_is_case(_case)

def psl_node_get_case_cond(_case: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_get_case_cond(PslNode_ptr _case) -> PslNode_ptr"""
    return _psl.psl_node_get_case_cond(_case)

def psl_node_get_case_then(_case: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_get_case_then(PslNode_ptr _case) -> PslNode_ptr"""
    return _psl.psl_node_get_case_then(_case)

def psl_node_get_case_next(_case: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_get_case_next(PslNode_ptr _case) -> PslNode_ptr"""
    return _psl.psl_node_get_case_next(_case)

def psl_node_is_serebrackets(e: 'PslNode_ptr') -> "boolean":
    """psl_node_is_serebrackets(PslNode_ptr e) -> boolean"""
    return _psl.psl_node_is_serebrackets(e)

def psl_node_sere_is_concat(e: 'PslNode_ptr') -> "boolean":
    """psl_node_sere_is_concat(PslNode_ptr e) -> boolean"""
    return _psl.psl_node_sere_is_concat(e)

def psl_node_sere_is_fusion(e: 'PslNode_ptr') -> "boolean":
    """psl_node_sere_is_fusion(PslNode_ptr e) -> boolean"""
    return _psl.psl_node_sere_is_fusion(e)

def psl_node_sere_concat_get_left(e: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_sere_concat_get_left(PslNode_ptr e) -> PslNode_ptr"""
    return _psl.psl_node_sere_concat_get_left(e)

def psl_node_sere_concat_get_right(e: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_sere_concat_get_right(PslNode_ptr e) -> PslNode_ptr"""
    return _psl.psl_node_sere_concat_get_right(e)

def psl_node_sere_concat_get_leftmost(e: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_sere_concat_get_leftmost(PslNode_ptr e) -> PslNode_ptr"""
    return _psl.psl_node_sere_concat_get_leftmost(e)

def psl_node_sere_concat_get_rightmost(e: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_sere_concat_get_rightmost(PslNode_ptr e) -> PslNode_ptr"""
    return _psl.psl_node_sere_concat_get_rightmost(e)

def psl_node_sere_concat_cut_leftmost(e: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_sere_concat_cut_leftmost(PslNode_ptr e) -> PslNode_ptr"""
    return _psl.psl_node_sere_concat_cut_leftmost(e)

def psl_node_sere_fusion_get_left(e: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_sere_fusion_get_left(PslNode_ptr e) -> PslNode_ptr"""
    return _psl.psl_node_sere_fusion_get_left(e)

def psl_node_sere_fusion_get_right(e: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_sere_fusion_get_right(PslNode_ptr e) -> PslNode_ptr"""
    return _psl.psl_node_sere_fusion_get_right(e)

def psl_node_sere_is_or(e: 'PslNode_ptr') -> "boolean":
    """psl_node_sere_is_or(PslNode_ptr e) -> boolean"""
    return _psl.psl_node_sere_is_or(e)

def psl_node_sere_propositional_get_expr(e: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_sere_propositional_get_expr(PslNode_ptr e) -> PslNode_ptr"""
    return _psl.psl_node_sere_propositional_get_expr(e)

def psl_node_sere_compound_get_left(e: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_sere_compound_get_left(PslNode_ptr e) -> PslNode_ptr"""
    return _psl.psl_node_sere_compound_get_left(e)

def psl_node_sere_compound_get_right(e: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_sere_compound_get_right(PslNode_ptr e) -> PslNode_ptr"""
    return _psl.psl_node_sere_compound_get_right(e)

def psl_node_make_sere_propositional(expr: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_make_sere_propositional(PslNode_ptr expr) -> PslNode_ptr"""
    return _psl.psl_node_make_sere_propositional(expr)

def psl_node_make_sere_concat(seq1: 'PslNode_ptr', seq2: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_make_sere_concat(PslNode_ptr seq1, PslNode_ptr seq2) -> PslNode_ptr"""
    return _psl.psl_node_make_sere_concat(seq1, seq2)

def psl_node_make_sere_2ampersand(seq1: 'PslNode_ptr', seq2: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_make_sere_2ampersand(PslNode_ptr seq1, PslNode_ptr seq2) -> PslNode_ptr"""
    return _psl.psl_node_make_sere_2ampersand(seq1, seq2)

def psl_node_make_sere_star(seq: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_make_sere_star(PslNode_ptr seq) -> PslNode_ptr"""
    return _psl.psl_node_make_sere_star(seq)

def psl_node_make_sere_compound(seq1: 'PslNode_ptr', op: 'PslOp', seq2: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_make_sere_compound(PslNode_ptr seq1, PslOp op, PslNode_ptr seq2) -> PslNode_ptr"""
    return _psl.psl_node_make_sere_compound(seq1, op, seq2)

def psl_node_is_sere_compound_binary(e: 'PslNode_ptr') -> "boolean":
    """psl_node_is_sere_compound_binary(PslNode_ptr e) -> boolean"""
    return _psl.psl_node_is_sere_compound_binary(e)

def psl_node_make_cons(elem: 'PslNode_ptr', next: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_make_cons(PslNode_ptr elem, PslNode_ptr next) -> PslNode_ptr"""
    return _psl.psl_node_make_cons(elem, next)

def psl_node_make_cons_new(elem: 'PslNode_ptr', next: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_make_cons_new(PslNode_ptr elem, PslNode_ptr next) -> PslNode_ptr"""
    return _psl.psl_node_make_cons_new(elem, next)

def psl_node_is_boolean_type(expr: 'PslNode_ptr') -> "boolean":
    """psl_node_is_boolean_type(PslNode_ptr expr) -> boolean"""
    return _psl.psl_node_is_boolean_type(expr)

def psl_node_is_leaf(expr: 'PslNode_ptr') -> "boolean":
    """psl_node_is_leaf(PslNode_ptr expr) -> boolean"""
    return _psl.psl_node_is_leaf(expr)

def psl_node_is_infinite(expr: 'PslNode_ptr') -> "boolean":
    """psl_node_is_infinite(PslNode_ptr expr) -> boolean"""
    return _psl.psl_node_is_infinite(expr)

def psl_node_is_id(expr: 'PslNode_ptr') -> "boolean":
    """psl_node_is_id(PslNode_ptr expr) -> boolean"""
    return _psl.psl_node_is_id(expr)

def psl_node_is_id_equal(_id1: 'PslNode_ptr', _id2: 'PslNode_ptr') -> "boolean":
    """psl_node_is_id_equal(PslNode_ptr _id1, PslNode_ptr _id2) -> boolean"""
    return _psl.psl_node_is_id_equal(_id1, _id2)

def psl_node_is_number(e: 'PslNode_ptr') -> "boolean":
    """psl_node_is_number(PslNode_ptr e) -> boolean"""
    return _psl.psl_node_is_number(e)

def psl_node_is_word_number(e: 'PslNode_ptr') -> "boolean":
    """psl_node_is_word_number(PslNode_ptr e) -> boolean"""
    return _psl.psl_node_is_word_number(e)

def psl_node_make_number(value: 'int') -> "PslNode_ptr":
    """psl_node_make_number(int value) -> PslNode_ptr"""
    return _psl.psl_node_make_number(value)

def psl_node_number_get_value(e: 'PslNode_ptr') -> "int":
    """psl_node_number_get_value(PslNode_ptr e) -> int"""
    return _psl.psl_node_number_get_value(e)

def psl_node_is_num_equal(_id1: 'PslNode_ptr', _id2: 'PslNode_ptr') -> "boolean":
    """psl_node_is_num_equal(PslNode_ptr _id1, PslNode_ptr _id2) -> boolean"""
    return _psl.psl_node_is_num_equal(_id1, _id2)

def psl_node_make_failure(msg: 'char const *', kind: 'FailureKind') -> "PslNode_ptr":
    """psl_node_make_failure(char const * msg, FailureKind kind) -> PslNode_ptr"""
    return _psl.psl_node_make_failure(msg, kind)

def psl_node_make_case(_cond: 'PslNode_ptr', _then: 'PslNode_ptr', _next: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_make_case(PslNode_ptr _cond, PslNode_ptr _then, PslNode_ptr _next) -> PslNode_ptr"""
    return _psl.psl_node_make_case(_cond, _then, _next)

def psl_node_is_range(expr: 'PslNode_ptr') -> "boolean":
    """psl_node_is_range(PslNode_ptr expr) -> boolean"""
    return _psl.psl_node_is_range(expr)

def psl_node_range_get_low(expr: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_range_get_low(PslNode_ptr expr) -> PslNode_ptr"""
    return _psl.psl_node_range_get_low(expr)

def psl_node_range_get_high(expr: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_range_get_high(PslNode_ptr expr) -> PslNode_ptr"""
    return _psl.psl_node_range_get_high(expr)

def psl_node_is_cons(e: 'PslNode_ptr') -> "boolean":
    """psl_node_is_cons(PslNode_ptr e) -> boolean"""
    return _psl.psl_node_is_cons(e)

def psl_node_cons_get_element(e: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_cons_get_element(PslNode_ptr e) -> PslNode_ptr"""
    return _psl.psl_node_cons_get_element(e)

def psl_node_cons_get_next(e: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_cons_get_next(PslNode_ptr e) -> PslNode_ptr"""
    return _psl.psl_node_cons_get_next(e)

def psl_node_cons_reverse(e: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_cons_reverse(PslNode_ptr e) -> PslNode_ptr"""
    return _psl.psl_node_cons_reverse(e)

def psl_node_suffix_implication_get_premise(e: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_suffix_implication_get_premise(PslNode_ptr e) -> PslNode_ptr"""
    return _psl.psl_node_suffix_implication_get_premise(e)

def psl_node_suffix_implication_get_consequence(e: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_suffix_implication_get_consequence(PslNode_ptr e) -> PslNode_ptr"""
    return _psl.psl_node_suffix_implication_get_consequence(e)

def psl_node_sere_repeated_get_expr(e: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_sere_repeated_get_expr(PslNode_ptr e) -> PslNode_ptr"""
    return _psl.psl_node_sere_repeated_get_expr(e)

def psl_node_sere_repeated_get_count(e: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_sere_repeated_get_count(PslNode_ptr e) -> PslNode_ptr"""
    return _psl.psl_node_sere_repeated_get_count(e)

def psl_node_sere_repeated_get_op(e: 'PslNode_ptr') -> "PslOp":
    """psl_node_sere_repeated_get_op(PslNode_ptr e) -> PslOp"""
    return _psl.psl_node_sere_repeated_get_op(e)

def psl_node_is_repl_prop(_prop: 'PslNode_ptr') -> "boolean":
    """psl_node_is_repl_prop(PslNode_ptr _prop) -> boolean"""
    return _psl.psl_node_is_repl_prop(_prop)

def psl_node_repl_prop_get_property(_prop: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_repl_prop_get_property(PslNode_ptr _prop) -> PslNode_ptr"""
    return _psl.psl_node_repl_prop_get_property(_prop)

def psl_node_repl_prop_get_replicator(_prop: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_repl_prop_get_replicator(PslNode_ptr _prop) -> PslNode_ptr"""
    return _psl.psl_node_repl_prop_get_replicator(_prop)

def psl_node_is_replicator(_repl: 'PslNode_ptr') -> "boolean":
    """psl_node_is_replicator(PslNode_ptr _repl) -> boolean"""
    return _psl.psl_node_is_replicator(_repl)

def psl_node_get_replicator_value_set(_repl: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_get_replicator_value_set(PslNode_ptr _repl) -> PslNode_ptr"""
    return _psl.psl_node_get_replicator_value_set(_repl)

def psl_node_get_replicator_join_op(_repl: 'PslNode_ptr') -> "PslOp":
    """psl_node_get_replicator_join_op(PslNode_ptr _repl) -> PslOp"""
    return _psl.psl_node_get_replicator_join_op(_repl)

def psl_node_get_replicator_normalized_value_set(rep: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_get_replicator_normalized_value_set(PslNode_ptr rep) -> PslNode_ptr"""
    return _psl.psl_node_get_replicator_normalized_value_set(rep)

def psl_node_get_replicator_range(_repl: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_get_replicator_range(PslNode_ptr _repl) -> PslNode_ptr"""
    return _psl.psl_node_get_replicator_range(_repl)

def psl_node_get_replicator_id(_repl: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_get_replicator_id(PslNode_ptr _repl) -> PslNode_ptr"""
    return _psl.psl_node_get_replicator_id(_repl)

def psl_node_context_to_main_context(context: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_context_to_main_context(PslNode_ptr context) -> PslNode_ptr"""
    return _psl.psl_node_context_to_main_context(context)

def PslNode_new_context(ctx: 'PslNode_ptr', node: 'PslNode_ptr') -> "PslNode_ptr":
    """PslNode_new_context(PslNode_ptr ctx, PslNode_ptr node) -> PslNode_ptr"""
    return _psl.PslNode_new_context(ctx, node)

def psl_node_make_extended_next(op: 'PslOp', expr: 'PslNode_ptr', when: 'PslNode_ptr', condition: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_make_extended_next(PslOp op, PslNode_ptr expr, PslNode_ptr when, PslNode_ptr condition) -> PslNode_ptr"""
    return _psl.psl_node_make_extended_next(op, expr, when, condition)

def psl_node_is_extended_next(e: 'PslNode_ptr') -> "boolean":
    """psl_node_is_extended_next(PslNode_ptr e) -> boolean"""
    return _psl.psl_node_is_extended_next(e)

def psl_node_extended_next_get_expr(next: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_extended_next_get_expr(PslNode_ptr next) -> PslNode_ptr"""
    return _psl.psl_node_extended_next_get_expr(next)

def psl_node_extended_next_get_when(next: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_extended_next_get_when(PslNode_ptr next) -> PslNode_ptr"""
    return _psl.psl_node_extended_next_get_when(next)

def psl_node_extended_next_get_condition(next: 'PslNode_ptr') -> "PslNode_ptr":
    """psl_node_extended_next_get_condition(PslNode_ptr next) -> PslNode_ptr"""
    return _psl.psl_node_extended_next_get_condition(next)

def PslNode_is_handled_psl(e: 'PslNode_ptr') -> "boolean":
    """PslNode_is_handled_psl(PslNode_ptr e) -> boolean"""
    return _psl.PslNode_is_handled_psl(e)

def PslNode_is_propositional(expr: 'PslNode_ptr const') -> "boolean":
    """PslNode_is_propositional(PslNode_ptr const expr) -> boolean"""
    return _psl.PslNode_is_propositional(expr)

def PslNode_is_trans_propositional(expr: 'PslNode_ptr const') -> "boolean":
    """PslNode_is_trans_propositional(PslNode_ptr const expr) -> boolean"""
    return _psl.PslNode_is_trans_propositional(expr)

def PslNode_propositional_contains_next(expr: 'PslNode_ptr const') -> "boolean":
    """PslNode_propositional_contains_next(PslNode_ptr const expr) -> boolean"""
    return _psl.PslNode_propositional_contains_next(expr)

def PslNode_is_obe(expr: 'PslNode_ptr const') -> "boolean":
    """PslNode_is_obe(PslNode_ptr const expr) -> boolean"""
    return _psl.PslNode_is_obe(expr)

def PslNode_is_ltl(expr: 'PslNode_ptr const') -> "boolean":
    """PslNode_is_ltl(PslNode_ptr const expr) -> boolean"""
    return _psl.PslNode_is_ltl(expr)

def PslNode_convert_id(id: 'PslNode_ptr', type: 'PslOpConvType') -> "PslNode_ptr":
    """PslNode_convert_id(PslNode_ptr id, PslOpConvType type) -> PslNode_ptr"""
    return _psl.PslNode_convert_id(id, type)

def PslNode_pslobe2ctl(expr: 'PslNode_ptr', type: 'PslOpConvType') -> "PslNode_ptr":
    """PslNode_pslobe2ctl(PslNode_ptr expr, PslOpConvType type) -> PslNode_ptr"""
    return _psl.PslNode_pslobe2ctl(expr, type)

def PslNode_pslltl2ltl(expr: 'PslNode_ptr', type: 'PslOpConvType') -> "PslNode_ptr":
    """PslNode_pslltl2ltl(PslNode_ptr expr, PslOpConvType type) -> PslNode_ptr"""
    return _psl.PslNode_pslltl2ltl(expr, type)

def PslNode_remove_sere(e: 'PslNode_ptr') -> "PslNode_ptr":
    """PslNode_remove_sere(PslNode_ptr e) -> PslNode_ptr"""
    return _psl.PslNode_remove_sere(e)

def PslNode_remove_forall_replicators(e: 'PslNode_ptr') -> "PslNode_ptr":
    """PslNode_remove_forall_replicators(PslNode_ptr e) -> PslNode_ptr"""
    return _psl.PslNode_remove_forall_replicators(e)
TKEOF = _psl.TKEOF
TKSTRING = _psl.TKSTRING
TKERROR = _psl.TKERROR
TKSTRUCT = _psl.TKSTRUCT
TKNUMBER = _psl.TKNUMBER
TKREALNUMBER = _psl.TKREALNUMBER
TKWORDNUMBER = _psl.TKWORDNUMBER
TKBASENUMBER = _psl.TKBASENUMBER
TKTRUE = _psl.TKTRUE
TKFALSE = _psl.TKFALSE
TKUNSIGNEDWORDNUMBER = _psl.TKUNSIGNEDWORDNUMBER
TKSIGNEDWORDNUMBER = _psl.TKSIGNEDWORDNUMBER
TKINCONTEXT = _psl.TKINCONTEXT
TKEQDEF = _psl.TKEQDEF
TKNAME = _psl.TKNAME
TKSERE = _psl.TKSERE
TKSERECONCAT = _psl.TKSERECONCAT
TKSEREFUSION = _psl.TKSEREFUSION
TKSERECOMPOUND = _psl.TKSERECOMPOUND
TKSEREREPEATED = _psl.TKSEREREPEATED
TKCONS = _psl.TKCONS
TKCONCATENATION = _psl.TKCONCATENATION
TKREPLPROP = _psl.TKREPLPROP
TKARRAY = _psl.TKARRAY
TKCONTEXT = _psl.TKCONTEXT
TKATOM = _psl.TKATOM
TKFAILURE = _psl.TKFAILURE
TKITE = _psl.TKITE
TKVUNIT = _psl.TKVUNIT
TKVMODE = _psl.TKVMODE
TKVPROP = _psl.TKVPROP
TKSTRONG = _psl.TKSTRONG
TKDEFPARAM = _psl.TKDEFPARAM
TKINHERIT = _psl.TKINHERIT
TKFAIRNESS = _psl.TKFAIRNESS
TKCONST = _psl.TKCONST
TKBEGIN = _psl.TKBEGIN
TKEND = _psl.TKEND
TKPARAMETER = _psl.TKPARAMETER
TKTASK = _psl.TKTASK
TKENDTASK = _psl.TKENDTASK
TKFORK = _psl.TKFORK
TKJOIN = _psl.TKJOIN
TKSUPPLY0 = _psl.TKSUPPLY0
TKSUPPLY1 = _psl.TKSUPPLY1
TKSTRONG0 = _psl.TKSTRONG0
TKPULL0 = _psl.TKPULL0
TKWEAK0 = _psl.TKWEAK0
TKHIGHZ0 = _psl.TKHIGHZ0
TKSTRONG1 = _psl.TKSTRONG1
TKPULL1 = _psl.TKPULL1
TKWEAK1 = _psl.TKWEAK1
TKHIGHZ1 = _psl.TKHIGHZ1
TKINPUT = _psl.TKINPUT
TKOUTPUT = _psl.TKOUTPUT
TKINOUT = _psl.TKINOUT
TKDEFAULT_CLOCK = _psl.TKDEFAULT_CLOCK
TKDEFAULT_COLON = _psl.TKDEFAULT_COLON
TKDEASSIGN = _psl.TKDEASSIGN
TKDISABLE = _psl.TKDISABLE
TKENDSPECIFY = _psl.TKENDSPECIFY
TKFOR = _psl.TKFOR
TKINITIAL = _psl.TKINITIAL
TKSPECIFY = _psl.TKSPECIFY
TKWAIT = _psl.TKWAIT
TKFOREVER = _psl.TKFOREVER
TKREPEAT = _psl.TKREPEAT
TKWHILE = _psl.TKWHILE
TKENDMODULE = _psl.TKENDMODULE
TKENDFUNCTION = _psl.TKENDFUNCTION
TKWIRE = _psl.TKWIRE
TKTRI = _psl.TKTRI
TKTRI1 = _psl.TKTRI1
TKWAND = _psl.TKWAND
TKTRIAND = _psl.TKTRIAND
TKTRI0 = _psl.TKTRI0
TKWOR = _psl.TKWOR
TKTRIOR = _psl.TKTRIOR
TKTRIREG = _psl.TKTRIREG
TKREG = _psl.TKREG
TKINTEGER = _psl.TKINTEGER
TKINF = _psl.TKINF
TKDOT = _psl.TKDOT
TKENDPOINT = _psl.TKENDPOINT
TKASSIGN = _psl.TKASSIGN
TKFORCE = _psl.TKFORCE
TKRELEASE = _psl.TKRELEASE
TKPROPERTY = _psl.TKPROPERTY
TKSEQUENCE = _psl.TKSEQUENCE
TKMODULE = _psl.TKMODULE
TKFUNCTION = _psl.TKFUNCTION
TKRESTRICT = _psl.TKRESTRICT
TKRESTRICT_GUARANTEE = _psl.TKRESTRICT_GUARANTEE
TKFORALL = _psl.TKFORALL
TKFORANY = _psl.TKFORANY
TKASSERT = _psl.TKASSERT
TKASSUME = _psl.TKASSUME
TKASSUME_GUARANTEE = _psl.TKASSUME_GUARANTEE
TKCOVER = _psl.TKCOVER
TKBOOLEAN = _psl.TKBOOLEAN
TKCASE = _psl.TKCASE
TKCASEX = _psl.TKCASEX
TKCASEZ = _psl.TKCASEZ
TKELSE = _psl.TKELSE
TKENDCASE = _psl.TKENDCASE
TKIF = _psl.TKIF
TKNONDET = _psl.TKNONDET
TKNONDET_VECTOR = _psl.TKNONDET_VECTOR
TKNONDET_RANGE = _psl.TKNONDET_RANGE
TKWNONDET = _psl.TKWNONDET
TKBASE = _psl.TKBASE
TKDOTDOT = _psl.TKDOTDOT
TKPIPEMINUSGT = _psl.TKPIPEMINUSGT
TKPIPEEQGT = _psl.TKPIPEEQGT
TKIDENTIFIER = _psl.TKIDENTIFIER
TKHIERARCHICALID = _psl.TKHIERARCHICALID
TKLP = _psl.TKLP
TKRP = _psl.TKRP
TKLC = _psl.TKLC
TKRC = _psl.TKRC
TKLB = _psl.TKLB
TKRB = _psl.TKRB
TKCOMMA = _psl.TKCOMMA
TKDIEZ = _psl.TKDIEZ
TKTRANS = _psl.TKTRANS
TKHINT = _psl.TKHINT
TKTEST_PINS = _psl.TKTEST_PINS
TKALWAYS = _psl.TKALWAYS
TKNEVER = _psl.TKNEVER
TKEVENTUALLYBANG = _psl.TKEVENTUALLYBANG
TKWITHINBANG = _psl.TKWITHINBANG
TKWITHIN = _psl.TKWITHIN
TKWITHINBANG_ = _psl.TKWITHINBANG_
TKWITHIN_ = _psl.TKWITHIN_
TKWHILENOTBANG = _psl.TKWHILENOTBANG
TKWHILENOT = _psl.TKWHILENOT
TKWHILENOTBANG_ = _psl.TKWHILENOTBANG_
TKWHILENOT_ = _psl.TKWHILENOT_
TKNEXT_EVENT_ABANG = _psl.TKNEXT_EVENT_ABANG
TKNEXT_EVENT_A = _psl.TKNEXT_EVENT_A
TKNEXT_EVENT_EBANG = _psl.TKNEXT_EVENT_EBANG
TKNEXT_EVENT_E = _psl.TKNEXT_EVENT_E
TKNEXT_EVENTBANG = _psl.TKNEXT_EVENTBANG
TKNEXT_EVENT = _psl.TKNEXT_EVENT
TKNEXT_ABANG = _psl.TKNEXT_ABANG
TKNEXT_EBANG = _psl.TKNEXT_EBANG
TKNEXT_A = _psl.TKNEXT_A
TKNEXT_E = _psl.TKNEXT_E
TKNEXTBANG = _psl.TKNEXTBANG
TKNEXT = _psl.TKNEXT
TKNEXTfunc = _psl.TKNEXTfunc
TKBEFOREBANG = _psl.TKBEFOREBANG
TKBEFORE = _psl.TKBEFORE
TKBEFOREBANG_ = _psl.TKBEFOREBANG_
TKBEFORE_ = _psl.TKBEFORE_
TKUNTILBANG = _psl.TKUNTILBANG
TKUNTIL = _psl.TKUNTIL
TKUNTILBANG_ = _psl.TKUNTILBANG_
TKUNTIL_ = _psl.TKUNTIL_
TKABORT = _psl.TKABORT
TKROSE = _psl.TKROSE
TKFELL = _psl.TKFELL
TKPREV = _psl.TKPREV
TKG = _psl.TKG
TKXBANG = _psl.TKXBANG
TKX = _psl.TKX
TKF = _psl.TKF
TKU = _psl.TKU
TKW = _psl.TKW
TKEG = _psl.TKEG
TKEX = _psl.TKEX
TKEF = _psl.TKEF
TKAG = _psl.TKAG
TKAX = _psl.TKAX
TKAF = _psl.TKAF
TKA = _psl.TKA
TKE = _psl.TKE
TKIN = _psl.TKIN
TKUNION = _psl.TKUNION
TKQUESTIONMARK = _psl.TKQUESTIONMARK
TKCOLON = _psl.TKCOLON
TKSEMI = _psl.TKSEMI
TKPIPEPIPE = _psl.TKPIPEPIPE
TKAMPERSANDAMPERSAND = _psl.TKAMPERSANDAMPERSAND
TKMINUSGT = _psl.TKMINUSGT
TKLTMINUSGT = _psl.TKLTMINUSGT
TKPIPE = _psl.TKPIPE
TKTILDEPIPE = _psl.TKTILDEPIPE
TKOR = _psl.TKOR
TKPOSEDGE = _psl.TKPOSEDGE
TKNEGEDGE = _psl.TKNEGEDGE
TKCARET = _psl.TKCARET
TKXOR = _psl.TKXOR
TKXNOR = _psl.TKXNOR
TKCARETTILDE = _psl.TKCARETTILDE
TKTILDECARET = _psl.TKTILDECARET
TKAMPERSAND = _psl.TKAMPERSAND
TKTILDEAMPERSAND = _psl.TKTILDEAMPERSAND
TKEQEQ = _psl.TKEQEQ
TKBANGEQ = _psl.TKBANGEQ
TKEQEQEQ = _psl.TKEQEQEQ
TKBANGEQEQ = _psl.TKBANGEQEQ
TKEQ = _psl.TKEQ
TKGT = _psl.TKGT
TKGE = _psl.TKGE
TKLT = _psl.TKLT
TKLE = _psl.TKLE
TKLTLT = _psl.TKLTLT
TKGTGT = _psl.TKGTGT
TKWSELECT = _psl.TKWSELECT
TKGTGTGT = _psl.TKGTGTGT
TKLTLTLT = _psl.TKLTLTLT
TKPLUS = _psl.TKPLUS
TKMINUS = _psl.TKMINUS
TKSPLAT = _psl.TKSPLAT
TKSLASH = _psl.TKSLASH
TKPERCENT = _psl.TKPERCENT
TKSPLATSPLAT = _psl.TKSPLATSPLAT
TKBANG = _psl.TKBANG
TKTILDE = _psl.TKTILDE
TKLBSPLAT = _psl.TKLBSPLAT
TKLBEQ = _psl.TKLBEQ
TKLBMINUSGT = _psl.TKLBMINUSGT
TKLBPLUSRB = _psl.TKLBPLUSRB
TKWCONCATENATION = _psl.TKWCONCATENATION
TKBOOL = _psl.TKBOOL
TKWRESIZE = _psl.TKWRESIZE
TKWSIZEOF = _psl.TKWSIZEOF
TKWTOINT = _psl.TKWTOINT
TKUWCONST = _psl.TKUWCONST
TKBITSELECTION = _psl.TKBITSELECTION
TKUMINUS = _psl.TKUMINUS
TKSWCONST = _psl.TKSWCONST
TKWORD1 = _psl.TKWORD1
TKSIGNED = _psl.TKSIGNED
TKUNSIGNED = _psl.TKUNSIGNED
TKEXTEND = _psl.TKEXTEND
TKSTRUDLE = _psl.TKSTRUDLE
TKSEREFORGR = _psl.TKSEREFORGR
TKPSLSPEC = _psl.TKPSLSPEC
class YYSTYPE(_object):
    """Proxy of C YYSTYPE struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, YYSTYPE, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, YYSTYPE, name)
    __repr__ = _swig_repr
    __swig_setmethods__["node"] = _psl.YYSTYPE_node_set
    __swig_getmethods__["node"] = _psl.YYSTYPE_node_get
    if _newclass:
        node = _swig_property(_psl.YYSTYPE_node_get, _psl.YYSTYPE_node_set)
    __swig_setmethods__["lineno"] = _psl.YYSTYPE_lineno_set
    __swig_getmethods__["lineno"] = _psl.YYSTYPE_lineno_get
    if _newclass:
        lineno = _swig_property(_psl.YYSTYPE_lineno_get, _psl.YYSTYPE_lineno_set)
    __swig_setmethods__["ival"] = _psl.YYSTYPE_ival_set
    __swig_getmethods__["ival"] = _psl.YYSTYPE_ival_get
    if _newclass:
        ival = _swig_property(_psl.YYSTYPE_ival_get, _psl.YYSTYPE_ival_set)
    __swig_setmethods__["wval"] = _psl.YYSTYPE_wval_set
    __swig_getmethods__["wval"] = _psl.YYSTYPE_wval_get
    if _newclass:
        wval = _swig_property(_psl.YYSTYPE_wval_get, _psl.YYSTYPE_wval_set)
    __swig_setmethods__["fval"] = _psl.YYSTYPE_fval_set
    __swig_getmethods__["fval"] = _psl.YYSTYPE_fval_get
    if _newclass:
        fval = _swig_property(_psl.YYSTYPE_fval_get, _psl.YYSTYPE_fval_set)
    __swig_setmethods__["baseval"] = _psl.YYSTYPE_baseval_set
    __swig_getmethods__["baseval"] = _psl.YYSTYPE_baseval_get
    if _newclass:
        baseval = _swig_property(_psl.YYSTYPE_baseval_get, _psl.YYSTYPE_baseval_set)
    __swig_setmethods__["idname"] = _psl.YYSTYPE_idname_set
    __swig_getmethods__["idname"] = _psl.YYSTYPE_idname_get
    if _newclass:
        idname = _swig_property(_psl.YYSTYPE_idname_get, _psl.YYSTYPE_idname_set)
    __swig_setmethods__["psl_expr"] = _psl.YYSTYPE_psl_expr_set
    __swig_getmethods__["psl_expr"] = _psl.YYSTYPE_psl_expr_get
    if _newclass:
        psl_expr = _swig_property(_psl.YYSTYPE_psl_expr_get, _psl.YYSTYPE_psl_expr_set)
    __swig_setmethods__["operator"] = _psl.YYSTYPE_operator_set
    __swig_getmethods__["operator"] = _psl.YYSTYPE_operator_get
    if _newclass:
        operator = _swig_property(_psl.YYSTYPE_operator_get, _psl.YYSTYPE_operator_set)

    def __init__(self):
        """__init__(YYSTYPE self) -> YYSTYPE"""
        this = _psl.new_YYSTYPE()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _psl.delete_YYSTYPE
    __del__ = lambda self: None
YYSTYPE_swigregister = _psl.YYSTYPE_swigregister
YYSTYPE_swigregister(YYSTYPE)

YYSTYPE_IS_DECLARED = _psl.YYSTYPE_IS_DECLARED
YYSTYPE_IS_TRIVIAL = _psl.YYSTYPE_IS_TRIVIAL
NUSMV_PSL_SYMBOL_FIRST = _psl.NUSMV_PSL_SYMBOL_FIRST
PSL_SERE = _psl.PSL_SERE
PSL_SERECONCAT = _psl.PSL_SERECONCAT
PSL_SEREFUSION = _psl.PSL_SEREFUSION
PSL_SERECOMPOUND = _psl.PSL_SERECOMPOUND
PSL_SEREREPEATED = _psl.PSL_SEREREPEATED
PSL_CONCATENATION = _psl.PSL_CONCATENATION
PSL_REPLPROP = _psl.PSL_REPLPROP
PSL_INF = _psl.PSL_INF
PSL_FORALL = _psl.PSL_FORALL
PSL_FORANY = _psl.PSL_FORANY
PSL_PIPEMINUSGT = _psl.PSL_PIPEMINUSGT
PSL_DIAMONDMINUSGT = _psl.PSL_DIAMONDMINUSGT
PSL_PIPEEQGT = _psl.PSL_PIPEEQGT
PSL_ALWAYS = _psl.PSL_ALWAYS
PSL_NEVER = _psl.PSL_NEVER
PSL_EVENTUALLYBANG = _psl.PSL_EVENTUALLYBANG
PSL_WITHINBANG = _psl.PSL_WITHINBANG
PSL_WITHIN = _psl.PSL_WITHIN
PSL_WITHINBANG_ = _psl.PSL_WITHINBANG_
PSL_WITHIN_ = _psl.PSL_WITHIN_
PSL_WHILENOTBANG = _psl.PSL_WHILENOTBANG
PSL_WHILENOT = _psl.PSL_WHILENOT
PSL_WHILENOTBANG_ = _psl.PSL_WHILENOTBANG_
PSL_WHILENOT_ = _psl.PSL_WHILENOT_
PSL_NEXT_EVENT_ABANG = _psl.PSL_NEXT_EVENT_ABANG
PSL_NEXT_EVENT_A = _psl.PSL_NEXT_EVENT_A
PSL_NEXT_EVENT_EBANG = _psl.PSL_NEXT_EVENT_EBANG
PSL_NEXT_EVENT_E = _psl.PSL_NEXT_EVENT_E
PSL_NEXT_EVENTBANG = _psl.PSL_NEXT_EVENTBANG
PSL_NEXT_EVENT = _psl.PSL_NEXT_EVENT
PSL_NEXT_ABANG = _psl.PSL_NEXT_ABANG
PSL_NEXT_EBANG = _psl.PSL_NEXT_EBANG
PSL_NEXT_A = _psl.PSL_NEXT_A
PSL_NEXT_E = _psl.PSL_NEXT_E
PSL_NEXTBANG = _psl.PSL_NEXTBANG
PSL_NEXT = _psl.PSL_NEXT
PSL_BEFOREBANG = _psl.PSL_BEFOREBANG
PSL_BEFORE = _psl.PSL_BEFORE
PSL_BEFOREBANG_ = _psl.PSL_BEFOREBANG_
PSL_BEFORE_ = _psl.PSL_BEFORE_
PSL_UNTILBANG = _psl.PSL_UNTILBANG
PSL_UNTIL = _psl.PSL_UNTIL
PSL_UNTILBANG_ = _psl.PSL_UNTILBANG_
PSL_UNTIL_ = _psl.PSL_UNTIL_
PSL_ABORT = _psl.PSL_ABORT
PSL_XBANG = _psl.PSL_XBANG
PSL_X = _psl.PSL_X
PSL_W = _psl.PSL_W
PSL_PIPEPIPE = _psl.PSL_PIPEPIPE
PSL_AMPERSANDAMPERSAND = _psl.PSL_AMPERSANDAMPERSAND
PSL_OR = _psl.PSL_OR
PSL_CARET = _psl.PSL_CARET
PSL_LBSPLAT = _psl.PSL_LBSPLAT
PSL_LBEQ = _psl.PSL_LBEQ
PSL_LBMINUSGT = _psl.PSL_LBMINUSGT
PSL_LBPLUSRB = _psl.PSL_LBPLUSRB
PSL_TILDE = _psl.PSL_TILDE
PSL_EQEQ = _psl.PSL_EQEQ
PSL_RANGE = _psl.PSL_RANGE
PSL_ITE = _psl.PSL_ITE
PSL_WSELECT = _psl.PSL_WSELECT
NUSMV_PSL_SYMBOL_LAST = _psl.NUSMV_PSL_SYMBOL_LAST
# This file is compatible with both classic and new-style classes.

cvar = _psl.cvar

