# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.12
#
# 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 >= (3, 0, 0):
    new_instancemethod = lambda func, inst, cls: _impl.SWIG_PyInstanceMethod_New(func)
else:
    from new import instancemethod as new_instancemethod
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_impl')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_impl')
    _impl = 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('_impl', [dirname(__file__)])
        except ImportError:
            import _impl
            return _impl
        try:
            _mod = imp.load_module('_impl', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _impl = swig_import_helper()
    del swig_import_helper
else:
    import _impl
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):
        object.__setattr__(self, 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,)


def _swig_setattr_nondynamic_method(set):
    def set_attr(self, name, value):
        if (name == "thisown"):
            return self.this.own(value)
        if hasattr(self, name) or (name == "this"):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr


SHARED_PTR_DISOWN = _impl.SHARED_PTR_DISOWN
class SwigPyIterator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _impl.delete_SwigPyIterator
    def __iter__(self):
        return self
SwigPyIterator.value = new_instancemethod(_impl.SwigPyIterator_value, None, SwigPyIterator)
SwigPyIterator.incr = new_instancemethod(_impl.SwigPyIterator_incr, None, SwigPyIterator)
SwigPyIterator.decr = new_instancemethod(_impl.SwigPyIterator_decr, None, SwigPyIterator)
SwigPyIterator.distance = new_instancemethod(_impl.SwigPyIterator_distance, None, SwigPyIterator)
SwigPyIterator.equal = new_instancemethod(_impl.SwigPyIterator_equal, None, SwigPyIterator)
SwigPyIterator.copy = new_instancemethod(_impl.SwigPyIterator_copy, None, SwigPyIterator)
SwigPyIterator.next = new_instancemethod(_impl.SwigPyIterator_next, None, SwigPyIterator)
SwigPyIterator.__next__ = new_instancemethod(_impl.SwigPyIterator___next__, None, SwigPyIterator)
SwigPyIterator.previous = new_instancemethod(_impl.SwigPyIterator_previous, None, SwigPyIterator)
SwigPyIterator.advance = new_instancemethod(_impl.SwigPyIterator_advance, None, SwigPyIterator)
SwigPyIterator.__eq__ = new_instancemethod(_impl.SwigPyIterator___eq__, None, SwigPyIterator)
SwigPyIterator.__ne__ = new_instancemethod(_impl.SwigPyIterator___ne__, None, SwigPyIterator)
SwigPyIterator.__iadd__ = new_instancemethod(_impl.SwigPyIterator___iadd__, None, SwigPyIterator)
SwigPyIterator.__isub__ = new_instancemethod(_impl.SwigPyIterator___isub__, None, SwigPyIterator)
SwigPyIterator.__add__ = new_instancemethod(_impl.SwigPyIterator___add__, None, SwigPyIterator)
SwigPyIterator.__sub__ = new_instancemethod(_impl.SwigPyIterator___sub__, None, SwigPyIterator)
SwigPyIterator_swigregister = _impl.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

import buddy
class parse_error(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, s: 'std::string const &'):
        _impl.parse_error_swiginit(self, _impl.new_parse_error(s))
    __swig_destroy__ = _impl.delete_parse_error
parse_error_swigregister = _impl.parse_error_swigregister
parse_error_swigregister(parse_error)


def version() -> "char const *":
    return _impl.version()
version = _impl.version
class minato_isop(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _impl.minato_isop_swiginit(self, _impl.new_minato_isop(*args))
    __swig_destroy__ = _impl.delete_minato_isop
minato_isop.next = new_instancemethod(_impl.minato_isop_next, None, minato_isop)
minato_isop_swigregister = _impl.minato_isop_swigregister
minato_isop_swigregister(minato_isop)

class option_map(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _impl.option_map_swiginit(self, _impl.new_option_map())
    __swig_destroy__ = _impl.delete_option_map
option_map.parse_options = new_instancemethod(_impl.option_map_parse_options, None, option_map)
option_map.get = new_instancemethod(_impl.option_map_get, None, option_map)
option_map.get_str = new_instancemethod(_impl.option_map_get_str, None, option_map)
option_map.set_str = new_instancemethod(_impl.option_map_set_str, None, option_map)
option_map.report_unused_options = new_instancemethod(_impl.option_map_report_unused_options, None, option_map)
option_map.set = new_instancemethod(_impl.option_map_set, None, option_map)
option_map_swigregister = _impl.option_map_swigregister
option_map_swigregister(option_map)


def srand(seed: 'unsigned int') -> "void":
    return _impl.srand(seed)
srand = _impl.srand

def rrand(min: 'int', max: 'int') -> "int":
    return _impl.rrand(min, max)
rrand = _impl.rrand

def mrand(max: 'int') -> "int":
    return _impl.mrand(max)
mrand = _impl.mrand

def drand() -> "double":
    return _impl.drand()
drand = _impl.drand

def nrand() -> "double":
    return _impl.nrand()
nrand = _impl.nrand

def escape_rfc4180(os: 'ostream', str: 'std::string const &') -> "std::ostream &":
    return _impl.escape_rfc4180(os, str)
escape_rfc4180 = _impl.escape_rfc4180

def escape_latex(os: 'ostream', str: 'std::string const &') -> "std::ostream &":
    return _impl.escape_latex(os, str)
escape_latex = _impl.escape_latex

def escape_html(os: 'ostream', str: 'std::string const &') -> "std::ostream &":
    return _impl.escape_html(os, str)
escape_html = _impl.escape_html

def escape_str(*args) -> "std::string":
    return _impl.escape_str(*args)
escape_str = _impl.escape_str

def quote_shell_string(os: 'ostream', str: 'char const *') -> "std::ostream &":
    return _impl.quote_shell_string(os, str)
quote_shell_string = _impl.quote_shell_string
class trival(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    no_value = _impl.trival_no_value
    maybe_value = _impl.trival_maybe_value
    yes_value = _impl.trival_yes_value

    def __init__(self, *args):
        _impl.trival_swiginit(self, _impl.new_trival(*args))
    maybe = staticmethod(_impl.trival_maybe)

    def __nonzero__(self):
        return _impl.trival___nonzero__(self)
    __bool__ = __nonzero__


    __swig_destroy__ = _impl.delete_trival
trival.is_known = new_instancemethod(_impl.trival_is_known, None, trival)
trival.is_maybe = new_instancemethod(_impl.trival_is_maybe, None, trival)
trival.is_true = new_instancemethod(_impl.trival_is_true, None, trival)
trival.is_false = new_instancemethod(_impl.trival_is_false, None, trival)
trival.val = new_instancemethod(_impl.trival_val, None, trival)
trival.__repr__ = new_instancemethod(_impl.trival___repr__, None, trival)
trival.__str__ = new_instancemethod(_impl.trival___str__, None, trival)
trival.__neg__ = new_instancemethod(_impl.trival___neg__, None, trival)
trival.__and__ = new_instancemethod(_impl.trival___and__, None, trival)
trival.__or__ = new_instancemethod(_impl.trival___or__, None, trival)
trival.__eq__ = new_instancemethod(_impl.trival___eq__, None, trival)
trival.__ne__ = new_instancemethod(_impl.trival___ne__, None, trival)
trival_swigregister = _impl.trival_swigregister
trival_swigregister(trival)

def trival_maybe() -> "spot::trival":
    return _impl.trival_maybe()
trival_maybe = _impl.trival_maybe

op_ff = _impl.op_ff
op_tt = _impl.op_tt
op_eword = _impl.op_eword
op_ap = _impl.op_ap
op_Not = _impl.op_Not
op_X = _impl.op_X
op_F = _impl.op_F
op_G = _impl.op_G
op_Closure = _impl.op_Closure
op_NegClosure = _impl.op_NegClosure
op_NegClosureMarked = _impl.op_NegClosureMarked
op_Xor = _impl.op_Xor
op_Implies = _impl.op_Implies
op_Equiv = _impl.op_Equiv
op_U = _impl.op_U
op_R = _impl.op_R
op_W = _impl.op_W
op_M = _impl.op_M
op_EConcat = _impl.op_EConcat
op_EConcatMarked = _impl.op_EConcatMarked
op_UConcat = _impl.op_UConcat
op_Or = _impl.op_Or
op_OrRat = _impl.op_OrRat
op_And = _impl.op_And
op_AndRat = _impl.op_AndRat
op_AndNLM = _impl.op_AndNLM
op_Concat = _impl.op_Concat
op_Fusion = _impl.op_Fusion
op_Star = _impl.op_Star
op_FStar = _impl.op_FStar
op_first_match = _impl.op_first_match
class formula(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        _impl.formula_swiginit(self, _impl.new_formula(*args))
    __swig_destroy__ = _impl.delete_formula

    def __nonzero__(self):
        return _impl.formula___nonzero__(self)
    __bool__ = __nonzero__


    unbounded = staticmethod(_impl.formula_unbounded)
    ap = staticmethod(_impl.formula_ap)
    unop = staticmethod(_impl.formula_unop)
    Not = staticmethod(_impl.formula_Not)
    X = staticmethod(_impl.formula_X)
    F = staticmethod(_impl.formula_F)
    G = staticmethod(_impl.formula_G)
    Closure = staticmethod(_impl.formula_Closure)
    NegClosure = staticmethod(_impl.formula_NegClosure)
    NegClosureMarked = staticmethod(_impl.formula_NegClosureMarked)
    first_match = staticmethod(_impl.formula_first_match)
    binop = staticmethod(_impl.formula_binop)
    Xor = staticmethod(_impl.formula_Xor)
    Implies = staticmethod(_impl.formula_Implies)
    Equiv = staticmethod(_impl.formula_Equiv)
    U = staticmethod(_impl.formula_U)
    R = staticmethod(_impl.formula_R)
    W = staticmethod(_impl.formula_W)
    M = staticmethod(_impl.formula_M)
    EConcat = staticmethod(_impl.formula_EConcat)
    EConcatMarked = staticmethod(_impl.formula_EConcatMarked)
    UConcat = staticmethod(_impl.formula_UConcat)
    multop = staticmethod(_impl.formula_multop)
    Or = staticmethod(_impl.formula_Or)
    OrRat = staticmethod(_impl.formula_OrRat)
    And = staticmethod(_impl.formula_And)
    AndRat = staticmethod(_impl.formula_AndRat)
    AndNLM = staticmethod(_impl.formula_AndNLM)
    Concat = staticmethod(_impl.formula_Concat)
    Fusion = staticmethod(_impl.formula_Fusion)
    bunop = staticmethod(_impl.formula_bunop)
    Star = staticmethod(_impl.formula_Star)
    FStar = staticmethod(_impl.formula_FStar)
    nested_unop_range = staticmethod(_impl.formula_nested_unop_range)
    sugar_goto = staticmethod(_impl.formula_sugar_goto)
    sugar_equal = staticmethod(_impl.formula_sugar_equal)
    sugar_delay = staticmethod(_impl.formula_sugar_delay)
    ff = staticmethod(_impl.formula_ff)
    tt = staticmethod(_impl.formula_tt)
    eword = staticmethod(_impl.formula_eword)
    one_star = staticmethod(_impl.formula_one_star)
formula.__lt__ = new_instancemethod(_impl.formula___lt__, None, formula)
formula.__le__ = new_instancemethod(_impl.formula___le__, None, formula)
formula.__gt__ = new_instancemethod(_impl.formula___gt__, None, formula)
formula.__ge__ = new_instancemethod(_impl.formula___ge__, None, formula)
formula.__eq__ = new_instancemethod(_impl.formula___eq__, None, formula)
formula.__ne__ = new_instancemethod(_impl.formula___ne__, None, formula)
formula.kind = new_instancemethod(_impl.formula_kind, None, formula)
formula.kindstr = new_instancemethod(_impl.formula_kindstr, None, formula)
formula._is = new_instancemethod(_impl.formula__is, None, formula)
formula.get_child_of = new_instancemethod(_impl.formula_get_child_of, None, formula)
formula.min = new_instancemethod(_impl.formula_min, None, formula)
formula.max = new_instancemethod(_impl.formula_max, None, formula)
formula.size = new_instancemethod(_impl.formula_size, None, formula)
formula.is_leaf = new_instancemethod(_impl.formula_is_leaf, None, formula)
formula.id = new_instancemethod(_impl.formula_id, None, formula)
formula.is_ff = new_instancemethod(_impl.formula_is_ff, None, formula)
formula.is_tt = new_instancemethod(_impl.formula_is_tt, None, formula)
formula.is_eword = new_instancemethod(_impl.formula_is_eword, None, formula)
formula.is_constant = new_instancemethod(_impl.formula_is_constant, None, formula)
formula.is_Kleene_star = new_instancemethod(_impl.formula_is_Kleene_star, None, formula)
formula.is_literal = new_instancemethod(_impl.formula_is_literal, None, formula)
formula.ap_name = new_instancemethod(_impl.formula_ap_name, None, formula)
formula.dump = new_instancemethod(_impl.formula_dump, None, formula)
formula.all_but = new_instancemethod(_impl.formula_all_but, None, formula)
formula.boolean_count = new_instancemethod(_impl.formula_boolean_count, None, formula)
formula.boolean_operands = new_instancemethod(_impl.formula_boolean_operands, None, formula)
formula.is_boolean = new_instancemethod(_impl.formula_is_boolean, None, formula)
formula.is_sugar_free_boolean = new_instancemethod(_impl.formula_is_sugar_free_boolean, None, formula)
formula.is_in_nenoform = new_instancemethod(_impl.formula_is_in_nenoform, None, formula)
formula.is_syntactic_stutter_invariant = new_instancemethod(_impl.formula_is_syntactic_stutter_invariant, None, formula)
formula.is_sugar_free_ltl = new_instancemethod(_impl.formula_is_sugar_free_ltl, None, formula)
formula.is_ltl_formula = new_instancemethod(_impl.formula_is_ltl_formula, None, formula)
formula.is_psl_formula = new_instancemethod(_impl.formula_is_psl_formula, None, formula)
formula.is_sere_formula = new_instancemethod(_impl.formula_is_sere_formula, None, formula)
formula.is_finite = new_instancemethod(_impl.formula_is_finite, None, formula)
formula.is_eventual = new_instancemethod(_impl.formula_is_eventual, None, formula)
formula.is_universal = new_instancemethod(_impl.formula_is_universal, None, formula)
formula.is_syntactic_safety = new_instancemethod(_impl.formula_is_syntactic_safety, None, formula)
formula.is_syntactic_guarantee = new_instancemethod(_impl.formula_is_syntactic_guarantee, None, formula)
formula.is_syntactic_obligation = new_instancemethod(_impl.formula_is_syntactic_obligation, None, formula)
formula.is_syntactic_recurrence = new_instancemethod(_impl.formula_is_syntactic_recurrence, None, formula)
formula.is_syntactic_persistence = new_instancemethod(_impl.formula_is_syntactic_persistence, None, formula)
formula.is_marked = new_instancemethod(_impl.formula_is_marked, None, formula)
formula.accepts_eword = new_instancemethod(_impl.formula_accepts_eword, None, formula)
formula.has_lbt_atomic_props = new_instancemethod(_impl.formula_has_lbt_atomic_props, None, formula)
formula.has_spin_atomic_props = new_instancemethod(_impl.formula_has_spin_atomic_props, None, formula)
formula.__cmp__ = new_instancemethod(_impl.formula___cmp__, None, formula)
formula.__hash__ = new_instancemethod(_impl.formula___hash__, None, formula)
formula.__len__ = new_instancemethod(_impl.formula___len__, None, formula)
formula.__getitem__ = new_instancemethod(_impl.formula___getitem__, None, formula)
formula.__repr__ = new_instancemethod(_impl.formula___repr__, None, formula)
formula.__str__ = new_instancemethod(_impl.formula___str__, None, formula)
formula_swigregister = _impl.formula_swigregister
formula_swigregister(formula)

def formula_unbounded() -> "uint8_t":
    return _impl.formula_unbounded()
formula_unbounded = _impl.formula_unbounded

def formula_ap(*args) -> "spot::formula":
    return _impl.formula_ap(*args)
formula_ap = _impl.formula_ap

def formula_unop(o: 'spot::op', f: 'formula') -> "spot::formula":
    return _impl.formula_unop(o, f)
formula_unop = _impl.formula_unop

def formula_Not(f: 'formula') -> "spot::formula":
    return _impl.formula_Not(f)
formula_Not = _impl.formula_Not

def formula_X(*args) -> "spot::formula":
    return _impl.formula_X(*args)
formula_X = _impl.formula_X

def formula_F(*args) -> "spot::formula":
    return _impl.formula_F(*args)
formula_F = _impl.formula_F

def formula_G(*args) -> "spot::formula":
    return _impl.formula_G(*args)
formula_G = _impl.formula_G

def formula_Closure(f: 'formula') -> "spot::formula":
    return _impl.formula_Closure(f)
formula_Closure = _impl.formula_Closure

def formula_NegClosure(f: 'formula') -> "spot::formula":
    return _impl.formula_NegClosure(f)
formula_NegClosure = _impl.formula_NegClosure

def formula_NegClosureMarked(f: 'formula') -> "spot::formula":
    return _impl.formula_NegClosureMarked(f)
formula_NegClosureMarked = _impl.formula_NegClosureMarked

def formula_first_match(f: 'formula') -> "spot::formula":
    return _impl.formula_first_match(f)
formula_first_match = _impl.formula_first_match

def formula_binop(o: 'spot::op', f: 'formula', g: 'formula') -> "spot::formula":
    return _impl.formula_binop(o, f, g)
formula_binop = _impl.formula_binop

def formula_Xor(f: 'formula', g: 'formula') -> "spot::formula":
    return _impl.formula_Xor(f, g)
formula_Xor = _impl.formula_Xor

def formula_Implies(f: 'formula', g: 'formula') -> "spot::formula":
    return _impl.formula_Implies(f, g)
formula_Implies = _impl.formula_Implies

def formula_Equiv(f: 'formula', g: 'formula') -> "spot::formula":
    return _impl.formula_Equiv(f, g)
formula_Equiv = _impl.formula_Equiv

def formula_U(f: 'formula', g: 'formula') -> "spot::formula":
    return _impl.formula_U(f, g)
formula_U = _impl.formula_U

def formula_R(f: 'formula', g: 'formula') -> "spot::formula":
    return _impl.formula_R(f, g)
formula_R = _impl.formula_R

def formula_W(f: 'formula', g: 'formula') -> "spot::formula":
    return _impl.formula_W(f, g)
formula_W = _impl.formula_W

def formula_M(f: 'formula', g: 'formula') -> "spot::formula":
    return _impl.formula_M(f, g)
formula_M = _impl.formula_M

def formula_EConcat(f: 'formula', g: 'formula') -> "spot::formula":
    return _impl.formula_EConcat(f, g)
formula_EConcat = _impl.formula_EConcat

def formula_EConcatMarked(f: 'formula', g: 'formula') -> "spot::formula":
    return _impl.formula_EConcatMarked(f, g)
formula_EConcatMarked = _impl.formula_EConcatMarked

def formula_UConcat(f: 'formula', g: 'formula') -> "spot::formula":
    return _impl.formula_UConcat(f, g)
formula_UConcat = _impl.formula_UConcat

def formula_multop(o: 'spot::op', l: 'vectorformula') -> "spot::formula":
    return _impl.formula_multop(o, l)
formula_multop = _impl.formula_multop

def formula_Or(l: 'vectorformula') -> "spot::formula":
    return _impl.formula_Or(l)
formula_Or = _impl.formula_Or

def formula_OrRat(l: 'vectorformula') -> "spot::formula":
    return _impl.formula_OrRat(l)
formula_OrRat = _impl.formula_OrRat

def formula_And(l: 'vectorformula') -> "spot::formula":
    return _impl.formula_And(l)
formula_And = _impl.formula_And

def formula_AndRat(l: 'vectorformula') -> "spot::formula":
    return _impl.formula_AndRat(l)
formula_AndRat = _impl.formula_AndRat

def formula_AndNLM(l: 'vectorformula') -> "spot::formula":
    return _impl.formula_AndNLM(l)
formula_AndNLM = _impl.formula_AndNLM

def formula_Concat(l: 'vectorformula') -> "spot::formula":
    return _impl.formula_Concat(l)
formula_Concat = _impl.formula_Concat

def formula_Fusion(l: 'vectorformula') -> "spot::formula":
    return _impl.formula_Fusion(l)
formula_Fusion = _impl.formula_Fusion

def formula_bunop(*args) -> "spot::formula":
    return _impl.formula_bunop(*args)
formula_bunop = _impl.formula_bunop

def formula_Star(*args) -> "spot::formula":
    return _impl.formula_Star(*args)
formula_Star = _impl.formula_Star

def formula_FStar(*args) -> "spot::formula":
    return _impl.formula_FStar(*args)
formula_FStar = _impl.formula_FStar

def formula_nested_unop_range(uo: 'spot::op', bo: 'spot::op', min: 'unsigned int', max: 'unsigned int', f: 'formula') -> "spot::formula const":
    return _impl.formula_nested_unop_range(uo, bo, min, max, f)
formula_nested_unop_range = _impl.formula_nested_unop_range

def formula_sugar_goto(b: 'formula', min: 'uint8_t', max: 'uint8_t') -> "spot::formula":
    return _impl.formula_sugar_goto(b, min, max)
formula_sugar_goto = _impl.formula_sugar_goto

def formula_sugar_equal(b: 'formula', min: 'uint8_t', max: 'uint8_t') -> "spot::formula":
    return _impl.formula_sugar_equal(b, min, max)
formula_sugar_equal = _impl.formula_sugar_equal

def formula_sugar_delay(*args) -> "spot::formula":
    return _impl.formula_sugar_delay(*args)
formula_sugar_delay = _impl.formula_sugar_delay

def formula_ff() -> "spot::formula":
    return _impl.formula_ff()
formula_ff = _impl.formula_ff

def formula_tt() -> "spot::formula":
    return _impl.formula_tt()
formula_tt = _impl.formula_tt

def formula_eword() -> "spot::formula":
    return _impl.formula_eword()
formula_eword = _impl.formula_eword

def formula_one_star() -> "spot::formula":
    return _impl.formula_one_star()
formula_one_star = _impl.formula_one_star


def print_formula_props(out: 'ostream', f: 'formula', abbreviated: 'bool'=False) -> "std::ostream &":
    return _impl.print_formula_props(out, f, abbreviated)
print_formula_props = _impl.print_formula_props

def list_formula_props(f: 'formula') -> "std::list< std::string,std::allocator< std::string > >":
    return _impl.list_formula_props(f)
list_formula_props = _impl.list_formula_props
class liststr(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __iter__(self):
        return self.iterator()

    def __init__(self, *args):
        _impl.liststr_swiginit(self, _impl.new_liststr(*args))
    __swig_destroy__ = _impl.delete_liststr
liststr.iterator = new_instancemethod(_impl.liststr_iterator, None, liststr)
liststr.__nonzero__ = new_instancemethod(_impl.liststr___nonzero__, None, liststr)
liststr.__bool__ = new_instancemethod(_impl.liststr___bool__, None, liststr)
liststr.__len__ = new_instancemethod(_impl.liststr___len__, None, liststr)
liststr.__getslice__ = new_instancemethod(_impl.liststr___getslice__, None, liststr)
liststr.__setslice__ = new_instancemethod(_impl.liststr___setslice__, None, liststr)
liststr.__delslice__ = new_instancemethod(_impl.liststr___delslice__, None, liststr)
liststr.__delitem__ = new_instancemethod(_impl.liststr___delitem__, None, liststr)
liststr.__getitem__ = new_instancemethod(_impl.liststr___getitem__, None, liststr)
liststr.__setitem__ = new_instancemethod(_impl.liststr___setitem__, None, liststr)
liststr.pop = new_instancemethod(_impl.liststr_pop, None, liststr)
liststr.append = new_instancemethod(_impl.liststr_append, None, liststr)
liststr.empty = new_instancemethod(_impl.liststr_empty, None, liststr)
liststr.size = new_instancemethod(_impl.liststr_size, None, liststr)
liststr.swap = new_instancemethod(_impl.liststr_swap, None, liststr)
liststr.begin = new_instancemethod(_impl.liststr_begin, None, liststr)
liststr.end = new_instancemethod(_impl.liststr_end, None, liststr)
liststr.rbegin = new_instancemethod(_impl.liststr_rbegin, None, liststr)
liststr.rend = new_instancemethod(_impl.liststr_rend, None, liststr)
liststr.clear = new_instancemethod(_impl.liststr_clear, None, liststr)
liststr.get_allocator = new_instancemethod(_impl.liststr_get_allocator, None, liststr)
liststr.pop_back = new_instancemethod(_impl.liststr_pop_back, None, liststr)
liststr.erase = new_instancemethod(_impl.liststr_erase, None, liststr)
liststr.push_back = new_instancemethod(_impl.liststr_push_back, None, liststr)
liststr.front = new_instancemethod(_impl.liststr_front, None, liststr)
liststr.back = new_instancemethod(_impl.liststr_back, None, liststr)
liststr.assign = new_instancemethod(_impl.liststr_assign, None, liststr)
liststr.resize = new_instancemethod(_impl.liststr_resize, None, liststr)
liststr.insert = new_instancemethod(_impl.liststr_insert, None, liststr)
liststr.pop_front = new_instancemethod(_impl.liststr_pop_front, None, liststr)
liststr.push_front = new_instancemethod(_impl.liststr_push_front, None, liststr)
liststr.reverse = new_instancemethod(_impl.liststr_reverse, None, liststr)
liststr_swigregister = _impl.liststr_swigregister
liststr_swigregister(liststr)

class pairunsigned(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _impl.pairunsigned_swiginit(self, _impl.new_pairunsigned(*args))
    first = _swig_property(_impl.pairunsigned_first_get, _impl.pairunsigned_first_set)
    second = _swig_property(_impl.pairunsigned_second_get, _impl.pairunsigned_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _impl.delete_pairunsigned
pairunsigned_swigregister = _impl.pairunsigned_swigregister
pairunsigned_swigregister(pairunsigned)

class pairmark_t(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _impl.pairmark_t_swiginit(self, _impl.new_pairmark_t(*args))
    first = _swig_property(_impl.pairmark_t_first_get, _impl.pairmark_t_first_set)
    second = _swig_property(_impl.pairmark_t_second_get, _impl.pairmark_t_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _impl.delete_pairmark_t
pairmark_t_swigregister = _impl.pairmark_t_swigregister
pairmark_t_swigregister(pairmark_t)

class vectorformula(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __iter__(self):
        return self.iterator()

    def __init__(self, *args):
        _impl.vectorformula_swiginit(self, _impl.new_vectorformula(*args))
    __swig_destroy__ = _impl.delete_vectorformula
vectorformula.iterator = new_instancemethod(_impl.vectorformula_iterator, None, vectorformula)
vectorformula.__nonzero__ = new_instancemethod(_impl.vectorformula___nonzero__, None, vectorformula)
vectorformula.__bool__ = new_instancemethod(_impl.vectorformula___bool__, None, vectorformula)
vectorformula.__len__ = new_instancemethod(_impl.vectorformula___len__, None, vectorformula)
vectorformula.__getslice__ = new_instancemethod(_impl.vectorformula___getslice__, None, vectorformula)
vectorformula.__setslice__ = new_instancemethod(_impl.vectorformula___setslice__, None, vectorformula)
vectorformula.__delslice__ = new_instancemethod(_impl.vectorformula___delslice__, None, vectorformula)
vectorformula.__delitem__ = new_instancemethod(_impl.vectorformula___delitem__, None, vectorformula)
vectorformula.__getitem__ = new_instancemethod(_impl.vectorformula___getitem__, None, vectorformula)
vectorformula.__setitem__ = new_instancemethod(_impl.vectorformula___setitem__, None, vectorformula)
vectorformula.pop = new_instancemethod(_impl.vectorformula_pop, None, vectorformula)
vectorformula.append = new_instancemethod(_impl.vectorformula_append, None, vectorformula)
vectorformula.empty = new_instancemethod(_impl.vectorformula_empty, None, vectorformula)
vectorformula.size = new_instancemethod(_impl.vectorformula_size, None, vectorformula)
vectorformula.swap = new_instancemethod(_impl.vectorformula_swap, None, vectorformula)
vectorformula.begin = new_instancemethod(_impl.vectorformula_begin, None, vectorformula)
vectorformula.end = new_instancemethod(_impl.vectorformula_end, None, vectorformula)
vectorformula.rbegin = new_instancemethod(_impl.vectorformula_rbegin, None, vectorformula)
vectorformula.rend = new_instancemethod(_impl.vectorformula_rend, None, vectorformula)
vectorformula.clear = new_instancemethod(_impl.vectorformula_clear, None, vectorformula)
vectorformula.get_allocator = new_instancemethod(_impl.vectorformula_get_allocator, None, vectorformula)
vectorformula.pop_back = new_instancemethod(_impl.vectorformula_pop_back, None, vectorformula)
vectorformula.erase = new_instancemethod(_impl.vectorformula_erase, None, vectorformula)
vectorformula.push_back = new_instancemethod(_impl.vectorformula_push_back, None, vectorformula)
vectorformula.front = new_instancemethod(_impl.vectorformula_front, None, vectorformula)
vectorformula.back = new_instancemethod(_impl.vectorformula_back, None, vectorformula)
vectorformula.assign = new_instancemethod(_impl.vectorformula_assign, None, vectorformula)
vectorformula.resize = new_instancemethod(_impl.vectorformula_resize, None, vectorformula)
vectorformula.insert = new_instancemethod(_impl.vectorformula_insert, None, vectorformula)
vectorformula.reserve = new_instancemethod(_impl.vectorformula_reserve, None, vectorformula)
vectorformula.capacity = new_instancemethod(_impl.vectorformula_capacity, None, vectorformula)
vectorformula_swigregister = _impl.vectorformula_swigregister
vectorformula_swigregister(vectorformula)

class vectorunsigned(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __iter__(self):
        return self.iterator()

    def __init__(self, *args):
        _impl.vectorunsigned_swiginit(self, _impl.new_vectorunsigned(*args))
    __swig_destroy__ = _impl.delete_vectorunsigned
vectorunsigned.iterator = new_instancemethod(_impl.vectorunsigned_iterator, None, vectorunsigned)
vectorunsigned.__nonzero__ = new_instancemethod(_impl.vectorunsigned___nonzero__, None, vectorunsigned)
vectorunsigned.__bool__ = new_instancemethod(_impl.vectorunsigned___bool__, None, vectorunsigned)
vectorunsigned.__len__ = new_instancemethod(_impl.vectorunsigned___len__, None, vectorunsigned)
vectorunsigned.__getslice__ = new_instancemethod(_impl.vectorunsigned___getslice__, None, vectorunsigned)
vectorunsigned.__setslice__ = new_instancemethod(_impl.vectorunsigned___setslice__, None, vectorunsigned)
vectorunsigned.__delslice__ = new_instancemethod(_impl.vectorunsigned___delslice__, None, vectorunsigned)
vectorunsigned.__delitem__ = new_instancemethod(_impl.vectorunsigned___delitem__, None, vectorunsigned)
vectorunsigned.__getitem__ = new_instancemethod(_impl.vectorunsigned___getitem__, None, vectorunsigned)
vectorunsigned.__setitem__ = new_instancemethod(_impl.vectorunsigned___setitem__, None, vectorunsigned)
vectorunsigned.pop = new_instancemethod(_impl.vectorunsigned_pop, None, vectorunsigned)
vectorunsigned.append = new_instancemethod(_impl.vectorunsigned_append, None, vectorunsigned)
vectorunsigned.empty = new_instancemethod(_impl.vectorunsigned_empty, None, vectorunsigned)
vectorunsigned.size = new_instancemethod(_impl.vectorunsigned_size, None, vectorunsigned)
vectorunsigned.swap = new_instancemethod(_impl.vectorunsigned_swap, None, vectorunsigned)
vectorunsigned.begin = new_instancemethod(_impl.vectorunsigned_begin, None, vectorunsigned)
vectorunsigned.end = new_instancemethod(_impl.vectorunsigned_end, None, vectorunsigned)
vectorunsigned.rbegin = new_instancemethod(_impl.vectorunsigned_rbegin, None, vectorunsigned)
vectorunsigned.rend = new_instancemethod(_impl.vectorunsigned_rend, None, vectorunsigned)
vectorunsigned.clear = new_instancemethod(_impl.vectorunsigned_clear, None, vectorunsigned)
vectorunsigned.get_allocator = new_instancemethod(_impl.vectorunsigned_get_allocator, None, vectorunsigned)
vectorunsigned.pop_back = new_instancemethod(_impl.vectorunsigned_pop_back, None, vectorunsigned)
vectorunsigned.erase = new_instancemethod(_impl.vectorunsigned_erase, None, vectorunsigned)
vectorunsigned.push_back = new_instancemethod(_impl.vectorunsigned_push_back, None, vectorunsigned)
vectorunsigned.front = new_instancemethod(_impl.vectorunsigned_front, None, vectorunsigned)
vectorunsigned.back = new_instancemethod(_impl.vectorunsigned_back, None, vectorunsigned)
vectorunsigned.assign = new_instancemethod(_impl.vectorunsigned_assign, None, vectorunsigned)
vectorunsigned.resize = new_instancemethod(_impl.vectorunsigned_resize, None, vectorunsigned)
vectorunsigned.insert = new_instancemethod(_impl.vectorunsigned_insert, None, vectorunsigned)
vectorunsigned.reserve = new_instancemethod(_impl.vectorunsigned_reserve, None, vectorunsigned)
vectorunsigned.capacity = new_instancemethod(_impl.vectorunsigned_capacity, None, vectorunsigned)
vectorunsigned_swigregister = _impl.vectorunsigned_swigregister
vectorunsigned_swigregister(vectorunsigned)

class vectorpairunsigned(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __iter__(self):
        return self.iterator()

    def __init__(self, *args):
        _impl.vectorpairunsigned_swiginit(self, _impl.new_vectorpairunsigned(*args))
    __swig_destroy__ = _impl.delete_vectorpairunsigned
vectorpairunsigned.iterator = new_instancemethod(_impl.vectorpairunsigned_iterator, None, vectorpairunsigned)
vectorpairunsigned.__nonzero__ = new_instancemethod(_impl.vectorpairunsigned___nonzero__, None, vectorpairunsigned)
vectorpairunsigned.__bool__ = new_instancemethod(_impl.vectorpairunsigned___bool__, None, vectorpairunsigned)
vectorpairunsigned.__len__ = new_instancemethod(_impl.vectorpairunsigned___len__, None, vectorpairunsigned)
vectorpairunsigned.__getslice__ = new_instancemethod(_impl.vectorpairunsigned___getslice__, None, vectorpairunsigned)
vectorpairunsigned.__setslice__ = new_instancemethod(_impl.vectorpairunsigned___setslice__, None, vectorpairunsigned)
vectorpairunsigned.__delslice__ = new_instancemethod(_impl.vectorpairunsigned___delslice__, None, vectorpairunsigned)
vectorpairunsigned.__delitem__ = new_instancemethod(_impl.vectorpairunsigned___delitem__, None, vectorpairunsigned)
vectorpairunsigned.__getitem__ = new_instancemethod(_impl.vectorpairunsigned___getitem__, None, vectorpairunsigned)
vectorpairunsigned.__setitem__ = new_instancemethod(_impl.vectorpairunsigned___setitem__, None, vectorpairunsigned)
vectorpairunsigned.pop = new_instancemethod(_impl.vectorpairunsigned_pop, None, vectorpairunsigned)
vectorpairunsigned.append = new_instancemethod(_impl.vectorpairunsigned_append, None, vectorpairunsigned)
vectorpairunsigned.empty = new_instancemethod(_impl.vectorpairunsigned_empty, None, vectorpairunsigned)
vectorpairunsigned.size = new_instancemethod(_impl.vectorpairunsigned_size, None, vectorpairunsigned)
vectorpairunsigned.swap = new_instancemethod(_impl.vectorpairunsigned_swap, None, vectorpairunsigned)
vectorpairunsigned.begin = new_instancemethod(_impl.vectorpairunsigned_begin, None, vectorpairunsigned)
vectorpairunsigned.end = new_instancemethod(_impl.vectorpairunsigned_end, None, vectorpairunsigned)
vectorpairunsigned.rbegin = new_instancemethod(_impl.vectorpairunsigned_rbegin, None, vectorpairunsigned)
vectorpairunsigned.rend = new_instancemethod(_impl.vectorpairunsigned_rend, None, vectorpairunsigned)
vectorpairunsigned.clear = new_instancemethod(_impl.vectorpairunsigned_clear, None, vectorpairunsigned)
vectorpairunsigned.get_allocator = new_instancemethod(_impl.vectorpairunsigned_get_allocator, None, vectorpairunsigned)
vectorpairunsigned.pop_back = new_instancemethod(_impl.vectorpairunsigned_pop_back, None, vectorpairunsigned)
vectorpairunsigned.erase = new_instancemethod(_impl.vectorpairunsigned_erase, None, vectorpairunsigned)
vectorpairunsigned.push_back = new_instancemethod(_impl.vectorpairunsigned_push_back, None, vectorpairunsigned)
vectorpairunsigned.front = new_instancemethod(_impl.vectorpairunsigned_front, None, vectorpairunsigned)
vectorpairunsigned.back = new_instancemethod(_impl.vectorpairunsigned_back, None, vectorpairunsigned)
vectorpairunsigned.assign = new_instancemethod(_impl.vectorpairunsigned_assign, None, vectorpairunsigned)
vectorpairunsigned.resize = new_instancemethod(_impl.vectorpairunsigned_resize, None, vectorpairunsigned)
vectorpairunsigned.insert = new_instancemethod(_impl.vectorpairunsigned_insert, None, vectorpairunsigned)
vectorpairunsigned.reserve = new_instancemethod(_impl.vectorpairunsigned_reserve, None, vectorpairunsigned)
vectorpairunsigned.capacity = new_instancemethod(_impl.vectorpairunsigned_capacity, None, vectorpairunsigned)
vectorpairunsigned_swigregister = _impl.vectorpairunsigned_swigregister
vectorpairunsigned_swigregister(vectorpairunsigned)

class vectoracccond(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __iter__(self):
        return self.iterator()

    def __init__(self, *args):
        _impl.vectoracccond_swiginit(self, _impl.new_vectoracccond(*args))
    __swig_destroy__ = _impl.delete_vectoracccond
vectoracccond.iterator = new_instancemethod(_impl.vectoracccond_iterator, None, vectoracccond)
vectoracccond.__nonzero__ = new_instancemethod(_impl.vectoracccond___nonzero__, None, vectoracccond)
vectoracccond.__bool__ = new_instancemethod(_impl.vectoracccond___bool__, None, vectoracccond)
vectoracccond.__len__ = new_instancemethod(_impl.vectoracccond___len__, None, vectoracccond)
vectoracccond.__getslice__ = new_instancemethod(_impl.vectoracccond___getslice__, None, vectoracccond)
vectoracccond.__setslice__ = new_instancemethod(_impl.vectoracccond___setslice__, None, vectoracccond)
vectoracccond.__delslice__ = new_instancemethod(_impl.vectoracccond___delslice__, None, vectoracccond)
vectoracccond.__delitem__ = new_instancemethod(_impl.vectoracccond___delitem__, None, vectoracccond)
vectoracccond.__getitem__ = new_instancemethod(_impl.vectoracccond___getitem__, None, vectoracccond)
vectoracccond.__setitem__ = new_instancemethod(_impl.vectoracccond___setitem__, None, vectoracccond)
vectoracccond.pop = new_instancemethod(_impl.vectoracccond_pop, None, vectoracccond)
vectoracccond.append = new_instancemethod(_impl.vectoracccond_append, None, vectoracccond)
vectoracccond.empty = new_instancemethod(_impl.vectoracccond_empty, None, vectoracccond)
vectoracccond.size = new_instancemethod(_impl.vectoracccond_size, None, vectoracccond)
vectoracccond.swap = new_instancemethod(_impl.vectoracccond_swap, None, vectoracccond)
vectoracccond.begin = new_instancemethod(_impl.vectoracccond_begin, None, vectoracccond)
vectoracccond.end = new_instancemethod(_impl.vectoracccond_end, None, vectoracccond)
vectoracccond.rbegin = new_instancemethod(_impl.vectoracccond_rbegin, None, vectoracccond)
vectoracccond.rend = new_instancemethod(_impl.vectoracccond_rend, None, vectoracccond)
vectoracccond.clear = new_instancemethod(_impl.vectoracccond_clear, None, vectoracccond)
vectoracccond.get_allocator = new_instancemethod(_impl.vectoracccond_get_allocator, None, vectoracccond)
vectoracccond.pop_back = new_instancemethod(_impl.vectoracccond_pop_back, None, vectoracccond)
vectoracccond.erase = new_instancemethod(_impl.vectoracccond_erase, None, vectoracccond)
vectoracccond.push_back = new_instancemethod(_impl.vectoracccond_push_back, None, vectoracccond)
vectoracccond.front = new_instancemethod(_impl.vectoracccond_front, None, vectoracccond)
vectoracccond.back = new_instancemethod(_impl.vectoracccond_back, None, vectoracccond)
vectoracccond.assign = new_instancemethod(_impl.vectoracccond_assign, None, vectoracccond)
vectoracccond.resize = new_instancemethod(_impl.vectoracccond_resize, None, vectoracccond)
vectoracccond.insert = new_instancemethod(_impl.vectoracccond_insert, None, vectoracccond)
vectoracccond.reserve = new_instancemethod(_impl.vectoracccond_reserve, None, vectoracccond)
vectoracccond.capacity = new_instancemethod(_impl.vectoracccond_capacity, None, vectoracccond)
vectoracccond_swigregister = _impl.vectoracccond_swigregister
vectoracccond_swigregister(vectoracccond)

class vectoracccode(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __iter__(self):
        return self.iterator()

    def __init__(self, *args):
        _impl.vectoracccode_swiginit(self, _impl.new_vectoracccode(*args))
    __swig_destroy__ = _impl.delete_vectoracccode
vectoracccode.iterator = new_instancemethod(_impl.vectoracccode_iterator, None, vectoracccode)
vectoracccode.__nonzero__ = new_instancemethod(_impl.vectoracccode___nonzero__, None, vectoracccode)
vectoracccode.__bool__ = new_instancemethod(_impl.vectoracccode___bool__, None, vectoracccode)
vectoracccode.__len__ = new_instancemethod(_impl.vectoracccode___len__, None, vectoracccode)
vectoracccode.__getslice__ = new_instancemethod(_impl.vectoracccode___getslice__, None, vectoracccode)
vectoracccode.__setslice__ = new_instancemethod(_impl.vectoracccode___setslice__, None, vectoracccode)
vectoracccode.__delslice__ = new_instancemethod(_impl.vectoracccode___delslice__, None, vectoracccode)
vectoracccode.__delitem__ = new_instancemethod(_impl.vectoracccode___delitem__, None, vectoracccode)
vectoracccode.__getitem__ = new_instancemethod(_impl.vectoracccode___getitem__, None, vectoracccode)
vectoracccode.__setitem__ = new_instancemethod(_impl.vectoracccode___setitem__, None, vectoracccode)
vectoracccode.pop = new_instancemethod(_impl.vectoracccode_pop, None, vectoracccode)
vectoracccode.append = new_instancemethod(_impl.vectoracccode_append, None, vectoracccode)
vectoracccode.empty = new_instancemethod(_impl.vectoracccode_empty, None, vectoracccode)
vectoracccode.size = new_instancemethod(_impl.vectoracccode_size, None, vectoracccode)
vectoracccode.swap = new_instancemethod(_impl.vectoracccode_swap, None, vectoracccode)
vectoracccode.begin = new_instancemethod(_impl.vectoracccode_begin, None, vectoracccode)
vectoracccode.end = new_instancemethod(_impl.vectoracccode_end, None, vectoracccode)
vectoracccode.rbegin = new_instancemethod(_impl.vectoracccode_rbegin, None, vectoracccode)
vectoracccode.rend = new_instancemethod(_impl.vectoracccode_rend, None, vectoracccode)
vectoracccode.clear = new_instancemethod(_impl.vectoracccode_clear, None, vectoracccode)
vectoracccode.get_allocator = new_instancemethod(_impl.vectoracccode_get_allocator, None, vectoracccode)
vectoracccode.pop_back = new_instancemethod(_impl.vectoracccode_pop_back, None, vectoracccode)
vectoracccode.erase = new_instancemethod(_impl.vectoracccode_erase, None, vectoracccode)
vectoracccode.push_back = new_instancemethod(_impl.vectoracccode_push_back, None, vectoracccode)
vectoracccode.front = new_instancemethod(_impl.vectoracccode_front, None, vectoracccode)
vectoracccode.back = new_instancemethod(_impl.vectoracccode_back, None, vectoracccode)
vectoracccode.assign = new_instancemethod(_impl.vectoracccode_assign, None, vectoracccode)
vectoracccode.resize = new_instancemethod(_impl.vectoracccode_resize, None, vectoracccode)
vectoracccode.insert = new_instancemethod(_impl.vectoracccode_insert, None, vectoracccode)
vectoracccode.reserve = new_instancemethod(_impl.vectoracccode_reserve, None, vectoracccode)
vectoracccode.capacity = new_instancemethod(_impl.vectoracccode_capacity, None, vectoracccode)
vectoracccode_swigregister = _impl.vectoracccode_swigregister
vectoracccode_swigregister(vectoracccode)

class vectorbool(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __iter__(self):
        return self.iterator()

    def __init__(self, *args):
        _impl.vectorbool_swiginit(self, _impl.new_vectorbool(*args))
    __swig_destroy__ = _impl.delete_vectorbool
vectorbool.iterator = new_instancemethod(_impl.vectorbool_iterator, None, vectorbool)
vectorbool.__nonzero__ = new_instancemethod(_impl.vectorbool___nonzero__, None, vectorbool)
vectorbool.__bool__ = new_instancemethod(_impl.vectorbool___bool__, None, vectorbool)
vectorbool.__len__ = new_instancemethod(_impl.vectorbool___len__, None, vectorbool)
vectorbool.__getslice__ = new_instancemethod(_impl.vectorbool___getslice__, None, vectorbool)
vectorbool.__setslice__ = new_instancemethod(_impl.vectorbool___setslice__, None, vectorbool)
vectorbool.__delslice__ = new_instancemethod(_impl.vectorbool___delslice__, None, vectorbool)
vectorbool.__delitem__ = new_instancemethod(_impl.vectorbool___delitem__, None, vectorbool)
vectorbool.__getitem__ = new_instancemethod(_impl.vectorbool___getitem__, None, vectorbool)
vectorbool.__setitem__ = new_instancemethod(_impl.vectorbool___setitem__, None, vectorbool)
vectorbool.pop = new_instancemethod(_impl.vectorbool_pop, None, vectorbool)
vectorbool.append = new_instancemethod(_impl.vectorbool_append, None, vectorbool)
vectorbool.empty = new_instancemethod(_impl.vectorbool_empty, None, vectorbool)
vectorbool.size = new_instancemethod(_impl.vectorbool_size, None, vectorbool)
vectorbool.swap = new_instancemethod(_impl.vectorbool_swap, None, vectorbool)
vectorbool.begin = new_instancemethod(_impl.vectorbool_begin, None, vectorbool)
vectorbool.end = new_instancemethod(_impl.vectorbool_end, None, vectorbool)
vectorbool.rbegin = new_instancemethod(_impl.vectorbool_rbegin, None, vectorbool)
vectorbool.rend = new_instancemethod(_impl.vectorbool_rend, None, vectorbool)
vectorbool.clear = new_instancemethod(_impl.vectorbool_clear, None, vectorbool)
vectorbool.get_allocator = new_instancemethod(_impl.vectorbool_get_allocator, None, vectorbool)
vectorbool.pop_back = new_instancemethod(_impl.vectorbool_pop_back, None, vectorbool)
vectorbool.erase = new_instancemethod(_impl.vectorbool_erase, None, vectorbool)
vectorbool.push_back = new_instancemethod(_impl.vectorbool_push_back, None, vectorbool)
vectorbool.front = new_instancemethod(_impl.vectorbool_front, None, vectorbool)
vectorbool.back = new_instancemethod(_impl.vectorbool_back, None, vectorbool)
vectorbool.assign = new_instancemethod(_impl.vectorbool_assign, None, vectorbool)
vectorbool.resize = new_instancemethod(_impl.vectorbool_resize, None, vectorbool)
vectorbool.insert = new_instancemethod(_impl.vectorbool_insert, None, vectorbool)
vectorbool.reserve = new_instancemethod(_impl.vectorbool_reserve, None, vectorbool)
vectorbool.capacity = new_instancemethod(_impl.vectorbool_capacity, None, vectorbool)
vectorbool_swigregister = _impl.vectorbool_swigregister
vectorbool_swigregister(vectorbool)

class vectorbdd(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __iter__(self):
        return self.iterator()

    def __init__(self, *args):
        _impl.vectorbdd_swiginit(self, _impl.new_vectorbdd(*args))
    __swig_destroy__ = _impl.delete_vectorbdd
vectorbdd.iterator = new_instancemethod(_impl.vectorbdd_iterator, None, vectorbdd)
vectorbdd.__nonzero__ = new_instancemethod(_impl.vectorbdd___nonzero__, None, vectorbdd)
vectorbdd.__bool__ = new_instancemethod(_impl.vectorbdd___bool__, None, vectorbdd)
vectorbdd.__len__ = new_instancemethod(_impl.vectorbdd___len__, None, vectorbdd)
vectorbdd.__getslice__ = new_instancemethod(_impl.vectorbdd___getslice__, None, vectorbdd)
vectorbdd.__setslice__ = new_instancemethod(_impl.vectorbdd___setslice__, None, vectorbdd)
vectorbdd.__delslice__ = new_instancemethod(_impl.vectorbdd___delslice__, None, vectorbdd)
vectorbdd.__delitem__ = new_instancemethod(_impl.vectorbdd___delitem__, None, vectorbdd)
vectorbdd.__getitem__ = new_instancemethod(_impl.vectorbdd___getitem__, None, vectorbdd)
vectorbdd.__setitem__ = new_instancemethod(_impl.vectorbdd___setitem__, None, vectorbdd)
vectorbdd.pop = new_instancemethod(_impl.vectorbdd_pop, None, vectorbdd)
vectorbdd.append = new_instancemethod(_impl.vectorbdd_append, None, vectorbdd)
vectorbdd.empty = new_instancemethod(_impl.vectorbdd_empty, None, vectorbdd)
vectorbdd.size = new_instancemethod(_impl.vectorbdd_size, None, vectorbdd)
vectorbdd.swap = new_instancemethod(_impl.vectorbdd_swap, None, vectorbdd)
vectorbdd.begin = new_instancemethod(_impl.vectorbdd_begin, None, vectorbdd)
vectorbdd.end = new_instancemethod(_impl.vectorbdd_end, None, vectorbdd)
vectorbdd.rbegin = new_instancemethod(_impl.vectorbdd_rbegin, None, vectorbdd)
vectorbdd.rend = new_instancemethod(_impl.vectorbdd_rend, None, vectorbdd)
vectorbdd.clear = new_instancemethod(_impl.vectorbdd_clear, None, vectorbdd)
vectorbdd.get_allocator = new_instancemethod(_impl.vectorbdd_get_allocator, None, vectorbdd)
vectorbdd.pop_back = new_instancemethod(_impl.vectorbdd_pop_back, None, vectorbdd)
vectorbdd.erase = new_instancemethod(_impl.vectorbdd_erase, None, vectorbdd)
vectorbdd.push_back = new_instancemethod(_impl.vectorbdd_push_back, None, vectorbdd)
vectorbdd.front = new_instancemethod(_impl.vectorbdd_front, None, vectorbdd)
vectorbdd.back = new_instancemethod(_impl.vectorbdd_back, None, vectorbdd)
vectorbdd.assign = new_instancemethod(_impl.vectorbdd_assign, None, vectorbdd)
vectorbdd.resize = new_instancemethod(_impl.vectorbdd_resize, None, vectorbdd)
vectorbdd.insert = new_instancemethod(_impl.vectorbdd_insert, None, vectorbdd)
vectorbdd.reserve = new_instancemethod(_impl.vectorbdd_reserve, None, vectorbdd)
vectorbdd.capacity = new_instancemethod(_impl.vectorbdd_capacity, None, vectorbdd)
vectorbdd_swigregister = _impl.vectorbdd_swigregister
vectorbdd_swigregister(vectorbdd)

class vectorstring(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __iter__(self):
        return self.iterator()

    def __init__(self, *args):
        _impl.vectorstring_swiginit(self, _impl.new_vectorstring(*args))
    __swig_destroy__ = _impl.delete_vectorstring
vectorstring.iterator = new_instancemethod(_impl.vectorstring_iterator, None, vectorstring)
vectorstring.__nonzero__ = new_instancemethod(_impl.vectorstring___nonzero__, None, vectorstring)
vectorstring.__bool__ = new_instancemethod(_impl.vectorstring___bool__, None, vectorstring)
vectorstring.__len__ = new_instancemethod(_impl.vectorstring___len__, None, vectorstring)
vectorstring.__getslice__ = new_instancemethod(_impl.vectorstring___getslice__, None, vectorstring)
vectorstring.__setslice__ = new_instancemethod(_impl.vectorstring___setslice__, None, vectorstring)
vectorstring.__delslice__ = new_instancemethod(_impl.vectorstring___delslice__, None, vectorstring)
vectorstring.__delitem__ = new_instancemethod(_impl.vectorstring___delitem__, None, vectorstring)
vectorstring.__getitem__ = new_instancemethod(_impl.vectorstring___getitem__, None, vectorstring)
vectorstring.__setitem__ = new_instancemethod(_impl.vectorstring___setitem__, None, vectorstring)
vectorstring.pop = new_instancemethod(_impl.vectorstring_pop, None, vectorstring)
vectorstring.append = new_instancemethod(_impl.vectorstring_append, None, vectorstring)
vectorstring.empty = new_instancemethod(_impl.vectorstring_empty, None, vectorstring)
vectorstring.size = new_instancemethod(_impl.vectorstring_size, None, vectorstring)
vectorstring.swap = new_instancemethod(_impl.vectorstring_swap, None, vectorstring)
vectorstring.begin = new_instancemethod(_impl.vectorstring_begin, None, vectorstring)
vectorstring.end = new_instancemethod(_impl.vectorstring_end, None, vectorstring)
vectorstring.rbegin = new_instancemethod(_impl.vectorstring_rbegin, None, vectorstring)
vectorstring.rend = new_instancemethod(_impl.vectorstring_rend, None, vectorstring)
vectorstring.clear = new_instancemethod(_impl.vectorstring_clear, None, vectorstring)
vectorstring.get_allocator = new_instancemethod(_impl.vectorstring_get_allocator, None, vectorstring)
vectorstring.pop_back = new_instancemethod(_impl.vectorstring_pop_back, None, vectorstring)
vectorstring.erase = new_instancemethod(_impl.vectorstring_erase, None, vectorstring)
vectorstring.push_back = new_instancemethod(_impl.vectorstring_push_back, None, vectorstring)
vectorstring.front = new_instancemethod(_impl.vectorstring_front, None, vectorstring)
vectorstring.back = new_instancemethod(_impl.vectorstring_back, None, vectorstring)
vectorstring.assign = new_instancemethod(_impl.vectorstring_assign, None, vectorstring)
vectorstring.resize = new_instancemethod(_impl.vectorstring_resize, None, vectorstring)
vectorstring.insert = new_instancemethod(_impl.vectorstring_insert, None, vectorstring)
vectorstring.reserve = new_instancemethod(_impl.vectorstring_reserve, None, vectorstring)
vectorstring.capacity = new_instancemethod(_impl.vectorstring_capacity, None, vectorstring)
vectorstring_swigregister = _impl.vectorstring_swigregister
vectorstring_swigregister(vectorstring)

class atomic_prop_set(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __iter__(self):
        return self.iterator()

    def __init__(self, *args):
        _impl.atomic_prop_set_swiginit(self, _impl.new_atomic_prop_set(*args))
    __swig_destroy__ = _impl.delete_atomic_prop_set
atomic_prop_set.iterator = new_instancemethod(_impl.atomic_prop_set_iterator, None, atomic_prop_set)
atomic_prop_set.__nonzero__ = new_instancemethod(_impl.atomic_prop_set___nonzero__, None, atomic_prop_set)
atomic_prop_set.__bool__ = new_instancemethod(_impl.atomic_prop_set___bool__, None, atomic_prop_set)
atomic_prop_set.__len__ = new_instancemethod(_impl.atomic_prop_set___len__, None, atomic_prop_set)
atomic_prop_set.append = new_instancemethod(_impl.atomic_prop_set_append, None, atomic_prop_set)
atomic_prop_set.__contains__ = new_instancemethod(_impl.atomic_prop_set___contains__, None, atomic_prop_set)
atomic_prop_set.__getitem__ = new_instancemethod(_impl.atomic_prop_set___getitem__, None, atomic_prop_set)
atomic_prop_set.add = new_instancemethod(_impl.atomic_prop_set_add, None, atomic_prop_set)
atomic_prop_set.discard = new_instancemethod(_impl.atomic_prop_set_discard, None, atomic_prop_set)
atomic_prop_set.empty = new_instancemethod(_impl.atomic_prop_set_empty, None, atomic_prop_set)
atomic_prop_set.size = new_instancemethod(_impl.atomic_prop_set_size, None, atomic_prop_set)
atomic_prop_set.clear = new_instancemethod(_impl.atomic_prop_set_clear, None, atomic_prop_set)
atomic_prop_set.swap = new_instancemethod(_impl.atomic_prop_set_swap, None, atomic_prop_set)
atomic_prop_set.count = new_instancemethod(_impl.atomic_prop_set_count, None, atomic_prop_set)
atomic_prop_set.begin = new_instancemethod(_impl.atomic_prop_set_begin, None, atomic_prop_set)
atomic_prop_set.end = new_instancemethod(_impl.atomic_prop_set_end, None, atomic_prop_set)
atomic_prop_set.rbegin = new_instancemethod(_impl.atomic_prop_set_rbegin, None, atomic_prop_set)
atomic_prop_set.rend = new_instancemethod(_impl.atomic_prop_set_rend, None, atomic_prop_set)
atomic_prop_set.erase = new_instancemethod(_impl.atomic_prop_set_erase, None, atomic_prop_set)
atomic_prop_set.find = new_instancemethod(_impl.atomic_prop_set_find, None, atomic_prop_set)
atomic_prop_set.lower_bound = new_instancemethod(_impl.atomic_prop_set_lower_bound, None, atomic_prop_set)
atomic_prop_set.upper_bound = new_instancemethod(_impl.atomic_prop_set_upper_bound, None, atomic_prop_set)
atomic_prop_set.equal_range = new_instancemethod(_impl.atomic_prop_set_equal_range, None, atomic_prop_set)
atomic_prop_set.insert = new_instancemethod(_impl.atomic_prop_set_insert, None, atomic_prop_set)
atomic_prop_set.__str__ = new_instancemethod(_impl.atomic_prop_set___str__, None, atomic_prop_set)
atomic_prop_set.__repr__ = new_instancemethod(_impl.atomic_prop_set___repr__, None, atomic_prop_set)
atomic_prop_set_swigregister = _impl.atomic_prop_set_swigregister
atomic_prop_set_swigregister(atomic_prop_set)

class relabeling_map(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __iter__(self):
        return self.iterator()
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __init__(self, *args):
        _impl.relabeling_map_swiginit(self, _impl.new_relabeling_map(*args))
    __swig_destroy__ = _impl.delete_relabeling_map
relabeling_map.iterator = new_instancemethod(_impl.relabeling_map_iterator, None, relabeling_map)
relabeling_map.__nonzero__ = new_instancemethod(_impl.relabeling_map___nonzero__, None, relabeling_map)
relabeling_map.__bool__ = new_instancemethod(_impl.relabeling_map___bool__, None, relabeling_map)
relabeling_map.__len__ = new_instancemethod(_impl.relabeling_map___len__, None, relabeling_map)
relabeling_map.__getitem__ = new_instancemethod(_impl.relabeling_map___getitem__, None, relabeling_map)
relabeling_map.__delitem__ = new_instancemethod(_impl.relabeling_map___delitem__, None, relabeling_map)
relabeling_map.has_key = new_instancemethod(_impl.relabeling_map_has_key, None, relabeling_map)
relabeling_map.keys = new_instancemethod(_impl.relabeling_map_keys, None, relabeling_map)
relabeling_map.values = new_instancemethod(_impl.relabeling_map_values, None, relabeling_map)
relabeling_map.items = new_instancemethod(_impl.relabeling_map_items, None, relabeling_map)
relabeling_map.__contains__ = new_instancemethod(_impl.relabeling_map___contains__, None, relabeling_map)
relabeling_map.key_iterator = new_instancemethod(_impl.relabeling_map_key_iterator, None, relabeling_map)
relabeling_map.value_iterator = new_instancemethod(_impl.relabeling_map_value_iterator, None, relabeling_map)
relabeling_map.__setitem__ = new_instancemethod(_impl.relabeling_map___setitem__, None, relabeling_map)
relabeling_map.asdict = new_instancemethod(_impl.relabeling_map_asdict, None, relabeling_map)
relabeling_map.empty = new_instancemethod(_impl.relabeling_map_empty, None, relabeling_map)
relabeling_map.size = new_instancemethod(_impl.relabeling_map_size, None, relabeling_map)
relabeling_map.swap = new_instancemethod(_impl.relabeling_map_swap, None, relabeling_map)
relabeling_map.begin = new_instancemethod(_impl.relabeling_map_begin, None, relabeling_map)
relabeling_map.end = new_instancemethod(_impl.relabeling_map_end, None, relabeling_map)
relabeling_map.rbegin = new_instancemethod(_impl.relabeling_map_rbegin, None, relabeling_map)
relabeling_map.rend = new_instancemethod(_impl.relabeling_map_rend, None, relabeling_map)
relabeling_map.clear = new_instancemethod(_impl.relabeling_map_clear, None, relabeling_map)
relabeling_map.get_allocator = new_instancemethod(_impl.relabeling_map_get_allocator, None, relabeling_map)
relabeling_map.count = new_instancemethod(_impl.relabeling_map_count, None, relabeling_map)
relabeling_map.erase = new_instancemethod(_impl.relabeling_map_erase, None, relabeling_map)
relabeling_map.find = new_instancemethod(_impl.relabeling_map_find, None, relabeling_map)
relabeling_map.lower_bound = new_instancemethod(_impl.relabeling_map_lower_bound, None, relabeling_map)
relabeling_map.upper_bound = new_instancemethod(_impl.relabeling_map_upper_bound, None, relabeling_map)
relabeling_map_swigregister = _impl.relabeling_map_swigregister
relabeling_map_swigregister(relabeling_map)

class environment(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _impl.delete_environment
environment.require = new_instancemethod(_impl.environment_require, None, environment)
environment.name = new_instancemethod(_impl.environment_name, None, environment)
environment_swigregister = _impl.environment_swigregister
environment_swigregister(environment)

class declarative_environment(environment):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _impl.declarative_environment_swiginit(self, _impl.new_declarative_environment())
    __swig_destroy__ = _impl.delete_declarative_environment
declarative_environment.declare = new_instancemethod(_impl.declarative_environment_declare, None, declarative_environment)
declarative_environment.get_prop_map = new_instancemethod(_impl.declarative_environment_get_prop_map, None, declarative_environment)
declarative_environment_swigregister = _impl.declarative_environment_swigregister
declarative_environment_swigregister(declarative_environment)

class default_environment(environment):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _impl.delete_default_environment
    instance = staticmethod(_impl.default_environment_instance)
default_environment_swigregister = _impl.default_environment_swigregister
default_environment_swigregister(default_environment)

def default_environment_instance() -> "spot::default_environment &":
    return _impl.default_environment_instance()
default_environment_instance = _impl.default_environment_instance

class parse_error_list(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _impl.parse_error_list_swiginit(self, _impl.new_parse_error_list())
    __swig_destroy__ = _impl.delete_parse_error_list
parse_error_list.__nonzero__ = new_instancemethod(_impl.parse_error_list___nonzero__, None, parse_error_list)
parse_error_list.__bool__ = new_instancemethod(_impl.parse_error_list___bool__, None, parse_error_list)
parse_error_list_swigregister = _impl.parse_error_list_swigregister
parse_error_list_swigregister(parse_error_list)

class parsed_formula(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    f = _swig_property(_impl.parsed_formula_f_get, _impl.parsed_formula_f_set)
    input = _swig_property(_impl.parsed_formula_input_get, _impl.parsed_formula_input_set)
    errors = _swig_property(_impl.parsed_formula_errors_get, _impl.parsed_formula_errors_set)

    def __init__(self, *args):
        _impl.parsed_formula_swiginit(self, _impl.new_parsed_formula(*args))
    __swig_destroy__ = _impl.delete_parsed_formula
parsed_formula.format_errors = new_instancemethod(_impl.parsed_formula_format_errors, None, parsed_formula)
parsed_formula_swigregister = _impl.parsed_formula_swigregister
parsed_formula_swigregister(parsed_formula)


def parse_infix_psl(*args) -> "spot::parsed_formula":
    return _impl.parse_infix_psl(*args)
parse_infix_psl = _impl.parse_infix_psl

def parse_infix_boolean(*args) -> "spot::parsed_formula":
    return _impl.parse_infix_boolean(*args)
parse_infix_boolean = _impl.parse_infix_boolean

def parse_prefix_ltl(*args) -> "spot::parsed_formula":
    return _impl.parse_prefix_ltl(*args)
parse_prefix_ltl = _impl.parse_prefix_ltl

def parse_formula(*args) -> "spot::formula":
    return _impl.parse_formula(*args)
parse_formula = _impl.parse_formula

def parse_infix_sere(*args) -> "spot::parsed_formula":
    return _impl.parse_infix_sere(*args)
parse_infix_sere = _impl.parse_infix_sere

def fix_utf8_locations(input_string: 'std::string const &', error_list: 'parse_error_list') -> "void":
    return _impl.fix_utf8_locations(input_string, error_list)
fix_utf8_locations = _impl.fix_utf8_locations
class bdd_dict(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _impl.bdd_dict_swiginit(self, _impl.new_bdd_dict())
    __swig_destroy__ = _impl.delete_bdd_dict
    var_map = _swig_property(_impl.bdd_dict_var_map_get, _impl.bdd_dict_var_map_set)
    acc_map = _swig_property(_impl.bdd_dict_acc_map_get, _impl.bdd_dict_acc_map_set)
    anon = _impl.bdd_dict_anon
    var = _impl.bdd_dict_var
    acc = _impl.bdd_dict_acc
    bdd_map = _swig_property(_impl.bdd_dict_bdd_map_get, _impl.bdd_dict_bdd_map_set)
bdd_dict.has_registered_proposition = new_instancemethod(_impl.bdd_dict_has_registered_proposition, None, bdd_dict)
bdd_dict.varnum = new_instancemethod(_impl.bdd_dict_varnum, None, bdd_dict)
bdd_dict.register_acceptance_variable = new_instancemethod(_impl.bdd_dict_register_acceptance_variable, None, bdd_dict)
bdd_dict.dump = new_instancemethod(_impl.bdd_dict_dump, None, bdd_dict)
bdd_dict.assert_emptiness = new_instancemethod(_impl.bdd_dict_assert_emptiness, None, bdd_dict)
bdd_dict.__eq__ = new_instancemethod(_impl.bdd_dict___eq__, None, bdd_dict)
bdd_dict.__ne__ = new_instancemethod(_impl.bdd_dict___ne__, None, bdd_dict)
bdd_dict.register_proposition = new_instancemethod(_impl.bdd_dict_register_proposition, None, bdd_dict)
bdd_dict.unregister_all_my_variables = new_instancemethod(_impl.bdd_dict_unregister_all_my_variables, None, bdd_dict)
bdd_dict.unregister_variable = new_instancemethod(_impl.bdd_dict_unregister_variable, None, bdd_dict)
bdd_dict.register_all_variables_of = new_instancemethod(_impl.bdd_dict_register_all_variables_of, None, bdd_dict)
bdd_dict.register_anonymous_variables = new_instancemethod(_impl.bdd_dict_register_anonymous_variables, None, bdd_dict)
bdd_dict_swigregister = _impl.bdd_dict_swigregister
bdd_dict_swigregister(bdd_dict)


def make_bdd_dict() -> "spot::bdd_dict_ptr":
    return _impl.make_bdd_dict()
make_bdd_dict = _impl.make_bdd_dict

def bdd_print_sat(os: 'ostream', dict: 'spot::bdd_dict_ptr const &', b: 'bdd') -> "std::ostream &":
    return _impl.bdd_print_sat(os, dict, b)
bdd_print_sat = _impl.bdd_print_sat

def bdd_format_sat(dict: 'spot::bdd_dict_ptr const &', b: 'bdd') -> "std::string":
    return _impl.bdd_format_sat(dict, b)
bdd_format_sat = _impl.bdd_format_sat

def bdd_print_accset(os: 'ostream', dict: 'spot::bdd_dict_ptr const &', b: 'bdd') -> "std::ostream &":
    return _impl.bdd_print_accset(os, dict, b)
bdd_print_accset = _impl.bdd_print_accset

def bdd_format_accset(dict: 'spot::bdd_dict_ptr const &', b: 'bdd') -> "std::string":
    return _impl.bdd_format_accset(dict, b)
bdd_format_accset = _impl.bdd_format_accset

def bdd_print_set(os: 'ostream', dict: 'spot::bdd_dict_ptr const &', b: 'bdd') -> "std::ostream &":
    return _impl.bdd_print_set(os, dict, b)
bdd_print_set = _impl.bdd_print_set

def bdd_format_set(dict: 'spot::bdd_dict_ptr const &', b: 'bdd') -> "std::string":
    return _impl.bdd_format_set(dict, b)
bdd_format_set = _impl.bdd_format_set

def bdd_print_formula(os: 'ostream', dict: 'spot::bdd_dict_ptr const &', b: 'bdd') -> "std::ostream &":
    return _impl.bdd_print_formula(os, dict, b)
bdd_print_formula = _impl.bdd_print_formula

def bdd_format_formula(dict: 'spot::bdd_dict_ptr const &', b: 'bdd') -> "std::string":
    return _impl.bdd_format_formula(dict, b)
bdd_format_formula = _impl.bdd_format_formula

def enable_utf8() -> "void":
    return _impl.enable_utf8()
enable_utf8 = _impl.enable_utf8

def bdd_format_isop(dict: 'spot::bdd_dict_ptr const &', b: 'bdd') -> "std::string":
    return _impl.bdd_format_isop(dict, b)
bdd_format_isop = _impl.bdd_format_isop

def bdd_print_isop(os: 'ostream', dict: 'spot::bdd_dict_ptr const &', b: 'bdd') -> "std::ostream &":
    return _impl.bdd_print_isop(os, dict, b)
bdd_print_isop = _impl.bdd_print_isop

def formula_to_bdd(f: 'formula', d: 'spot::bdd_dict_ptr const &', for_me: 'void *') -> "bdd":
    return _impl.formula_to_bdd(f, d, for_me)
formula_to_bdd = _impl.formula_to_bdd

def bdd_to_formula(f: 'bdd', d: 'spot::bdd_dict_ptr const') -> "spot::formula":
    return _impl.bdd_to_formula(f, d)
bdd_to_formula = _impl.bdd_to_formula
class vector_rs_pair(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __iter__(self):
        return self.iterator()

    def __init__(self, *args):
        _impl.vector_rs_pair_swiginit(self, _impl.new_vector_rs_pair(*args))
    __swig_destroy__ = _impl.delete_vector_rs_pair
vector_rs_pair.iterator = new_instancemethod(_impl.vector_rs_pair_iterator, None, vector_rs_pair)
vector_rs_pair.__nonzero__ = new_instancemethod(_impl.vector_rs_pair___nonzero__, None, vector_rs_pair)
vector_rs_pair.__bool__ = new_instancemethod(_impl.vector_rs_pair___bool__, None, vector_rs_pair)
vector_rs_pair.__len__ = new_instancemethod(_impl.vector_rs_pair___len__, None, vector_rs_pair)
vector_rs_pair.__getslice__ = new_instancemethod(_impl.vector_rs_pair___getslice__, None, vector_rs_pair)
vector_rs_pair.__setslice__ = new_instancemethod(_impl.vector_rs_pair___setslice__, None, vector_rs_pair)
vector_rs_pair.__delslice__ = new_instancemethod(_impl.vector_rs_pair___delslice__, None, vector_rs_pair)
vector_rs_pair.__delitem__ = new_instancemethod(_impl.vector_rs_pair___delitem__, None, vector_rs_pair)
vector_rs_pair.__getitem__ = new_instancemethod(_impl.vector_rs_pair___getitem__, None, vector_rs_pair)
vector_rs_pair.__setitem__ = new_instancemethod(_impl.vector_rs_pair___setitem__, None, vector_rs_pair)
vector_rs_pair.pop = new_instancemethod(_impl.vector_rs_pair_pop, None, vector_rs_pair)
vector_rs_pair.append = new_instancemethod(_impl.vector_rs_pair_append, None, vector_rs_pair)
vector_rs_pair.empty = new_instancemethod(_impl.vector_rs_pair_empty, None, vector_rs_pair)
vector_rs_pair.size = new_instancemethod(_impl.vector_rs_pair_size, None, vector_rs_pair)
vector_rs_pair.swap = new_instancemethod(_impl.vector_rs_pair_swap, None, vector_rs_pair)
vector_rs_pair.begin = new_instancemethod(_impl.vector_rs_pair_begin, None, vector_rs_pair)
vector_rs_pair.end = new_instancemethod(_impl.vector_rs_pair_end, None, vector_rs_pair)
vector_rs_pair.rbegin = new_instancemethod(_impl.vector_rs_pair_rbegin, None, vector_rs_pair)
vector_rs_pair.rend = new_instancemethod(_impl.vector_rs_pair_rend, None, vector_rs_pair)
vector_rs_pair.clear = new_instancemethod(_impl.vector_rs_pair_clear, None, vector_rs_pair)
vector_rs_pair.get_allocator = new_instancemethod(_impl.vector_rs_pair_get_allocator, None, vector_rs_pair)
vector_rs_pair.pop_back = new_instancemethod(_impl.vector_rs_pair_pop_back, None, vector_rs_pair)
vector_rs_pair.erase = new_instancemethod(_impl.vector_rs_pair_erase, None, vector_rs_pair)
vector_rs_pair.push_back = new_instancemethod(_impl.vector_rs_pair_push_back, None, vector_rs_pair)
vector_rs_pair.front = new_instancemethod(_impl.vector_rs_pair_front, None, vector_rs_pair)
vector_rs_pair.back = new_instancemethod(_impl.vector_rs_pair_back, None, vector_rs_pair)
vector_rs_pair.assign = new_instancemethod(_impl.vector_rs_pair_assign, None, vector_rs_pair)
vector_rs_pair.resize = new_instancemethod(_impl.vector_rs_pair_resize, None, vector_rs_pair)
vector_rs_pair.insert = new_instancemethod(_impl.vector_rs_pair_insert, None, vector_rs_pair)
vector_rs_pair.reserve = new_instancemethod(_impl.vector_rs_pair_reserve, None, vector_rs_pair)
vector_rs_pair.capacity = new_instancemethod(_impl.vector_rs_pair_capacity, None, vector_rs_pair)
vector_rs_pair_swigregister = _impl.vector_rs_pair_swigregister
vector_rs_pair_swigregister(vector_rs_pair)

class acc_cond(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    acc_op_Inf = _impl.acc_cond_acc_op_Inf
    acc_op_Fin = _impl.acc_cond_acc_op_Fin
    acc_op_InfNeg = _impl.acc_cond_acc_op_InfNeg
    acc_op_FinNeg = _impl.acc_cond_acc_op_FinNeg
    acc_op_And = _impl.acc_cond_acc_op_And
    acc_op_Or = _impl.acc_cond_acc_op_Or

    def __init__(self, *args):
        _impl.acc_cond_swiginit(self, _impl.new_acc_cond(*args))
    __swig_destroy__ = _impl.delete_acc_cond
    inf = staticmethod(_impl.acc_cond_inf)
    inf_neg = staticmethod(_impl.acc_cond_inf_neg)
    fin = staticmethod(_impl.acc_cond_fin)
    fin_neg = staticmethod(_impl.acc_cond_fin_neg)
acc_cond.has_parity_prefix = new_instancemethod(_impl.acc_cond_has_parity_prefix, None, acc_cond)
acc_cond.set_acceptance = new_instancemethod(_impl.acc_cond_set_acceptance, None, acc_cond)
acc_cond.get_acceptance = new_instancemethod(_impl.acc_cond_get_acceptance, None, acc_cond)
acc_cond.__eq__ = new_instancemethod(_impl.acc_cond___eq__, None, acc_cond)
acc_cond.__ne__ = new_instancemethod(_impl.acc_cond___ne__, None, acc_cond)
acc_cond.uses_fin_acceptance = new_instancemethod(_impl.acc_cond_uses_fin_acceptance, None, acc_cond)
acc_cond.is_t = new_instancemethod(_impl.acc_cond_is_t, None, acc_cond)
acc_cond.is_all = new_instancemethod(_impl.acc_cond_is_all, None, acc_cond)
acc_cond.is_f = new_instancemethod(_impl.acc_cond_is_f, None, acc_cond)
acc_cond.is_none = new_instancemethod(_impl.acc_cond_is_none, None, acc_cond)
acc_cond.is_buchi = new_instancemethod(_impl.acc_cond_is_buchi, None, acc_cond)
acc_cond.is_co_buchi = new_instancemethod(_impl.acc_cond_is_co_buchi, None, acc_cond)
acc_cond.set_generalized_buchi = new_instancemethod(_impl.acc_cond_set_generalized_buchi, None, acc_cond)
acc_cond.set_generalized_co_buchi = new_instancemethod(_impl.acc_cond_set_generalized_co_buchi, None, acc_cond)
acc_cond.is_generalized_buchi = new_instancemethod(_impl.acc_cond_is_generalized_buchi, None, acc_cond)
acc_cond.is_generalized_co_buchi = new_instancemethod(_impl.acc_cond_is_generalized_co_buchi, None, acc_cond)
acc_cond.is_rabin = new_instancemethod(_impl.acc_cond_is_rabin, None, acc_cond)
acc_cond.is_streett = new_instancemethod(_impl.acc_cond_is_streett, None, acc_cond)
acc_cond.is_streett_like = new_instancemethod(_impl.acc_cond_is_streett_like, None, acc_cond)
acc_cond.is_rabin_like = new_instancemethod(_impl.acc_cond_is_rabin_like, None, acc_cond)
acc_cond.is_generalized_rabin = new_instancemethod(_impl.acc_cond_is_generalized_rabin, None, acc_cond)
acc_cond.is_generalized_streett = new_instancemethod(_impl.acc_cond_is_generalized_streett, None, acc_cond)
acc_cond.is_parity_max_equiv = new_instancemethod(_impl.acc_cond_is_parity_max_equiv, None, acc_cond)
acc_cond.is_parity = new_instancemethod(_impl.acc_cond_is_parity, None, acc_cond)
acc_cond.unit_propagation = new_instancemethod(_impl.acc_cond_unit_propagation, None, acc_cond)
acc_cond.unsat_mark = new_instancemethod(_impl.acc_cond_unsat_mark, None, acc_cond)
acc_cond.sat_mark = new_instancemethod(_impl.acc_cond_sat_mark, None, acc_cond)
acc_cond.add_sets = new_instancemethod(_impl.acc_cond_add_sets, None, acc_cond)
acc_cond.add_set = new_instancemethod(_impl.acc_cond_add_set, None, acc_cond)
acc_cond.mark = new_instancemethod(_impl.acc_cond_mark, None, acc_cond)
acc_cond.comp = new_instancemethod(_impl.acc_cond_comp, None, acc_cond)
acc_cond.all_sets = new_instancemethod(_impl.acc_cond_all_sets, None, acc_cond)
acc_cond.apply_permutation = new_instancemethod(_impl.acc_cond_apply_permutation, None, acc_cond)
acc_cond.apply_permutation_aux = new_instancemethod(_impl.acc_cond_apply_permutation_aux, None, acc_cond)
acc_cond.accepting = new_instancemethod(_impl.acc_cond_accepting, None, acc_cond)
acc_cond.inf_satisfiable = new_instancemethod(_impl.acc_cond_inf_satisfiable, None, acc_cond)
acc_cond.maybe_accepting = new_instancemethod(_impl.acc_cond_maybe_accepting, None, acc_cond)
acc_cond.accepting_sets = new_instancemethod(_impl.acc_cond_accepting_sets, None, acc_cond)
acc_cond.format = new_instancemethod(_impl.acc_cond_format, None, acc_cond)
acc_cond.num_sets = new_instancemethod(_impl.acc_cond_num_sets, None, acc_cond)
acc_cond.remove = new_instancemethod(_impl.acc_cond_remove, None, acc_cond)
acc_cond.strip = new_instancemethod(_impl.acc_cond_strip, None, acc_cond)
acc_cond.force_inf = new_instancemethod(_impl.acc_cond_force_inf, None, acc_cond)
acc_cond.restrict_to = new_instancemethod(_impl.acc_cond_restrict_to, None, acc_cond)
acc_cond.name = new_instancemethod(_impl.acc_cond_name, None, acc_cond)
acc_cond.fin_unit = new_instancemethod(_impl.acc_cond_fin_unit, None, acc_cond)
acc_cond.fin_one = new_instancemethod(_impl.acc_cond_fin_one, None, acc_cond)
acc_cond.top_disjuncts = new_instancemethod(_impl.acc_cond_top_disjuncts, None, acc_cond)
acc_cond.top_conjuncts = new_instancemethod(_impl.acc_cond_top_conjuncts, None, acc_cond)
acc_cond.__repr__ = new_instancemethod(_impl.acc_cond___repr__, None, acc_cond)
acc_cond.__str__ = new_instancemethod(_impl.acc_cond___str__, None, acc_cond)
acc_cond_swigregister = _impl.acc_cond_swigregister
acc_cond_swigregister(acc_cond)

def acc_cond_inf(*args) -> "spot::acc_cond::acc_code":
    return _impl.acc_cond_inf(*args)
acc_cond_inf = _impl.acc_cond_inf

def acc_cond_inf_neg(*args) -> "spot::acc_cond::acc_code":
    return _impl.acc_cond_inf_neg(*args)
acc_cond_inf_neg = _impl.acc_cond_inf_neg

def acc_cond_fin(*args) -> "spot::acc_cond::acc_code":
    return _impl.acc_cond_fin(*args)
acc_cond_fin = _impl.acc_cond_fin

def acc_cond_fin_neg(*args) -> "spot::acc_cond::acc_code":
    return _impl.acc_cond_fin_neg(*args)
acc_cond_fin_neg = _impl.acc_cond_fin_neg

class mark_t(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    max_accsets = staticmethod(_impl.mark_t_max_accsets)
    all = staticmethod(_impl.mark_t_all)

    def __nonzero__(self):
        return _impl.mark_t___nonzero__(self)
    __bool__ = __nonzero__



    def __init__(self, *args):
        _impl.mark_t_swiginit(self, _impl.new_mark_t(*args))
    __swig_destroy__ = _impl.delete_mark_t
mark_t.apply_permutation = new_instancemethod(_impl.mark_t_apply_permutation, None, mark_t)
mark_t.hash = new_instancemethod(_impl.mark_t_hash, None, mark_t)
mark_t.__eq__ = new_instancemethod(_impl.mark_t___eq__, None, mark_t)
mark_t.__ne__ = new_instancemethod(_impl.mark_t___ne__, None, mark_t)
mark_t.__lt__ = new_instancemethod(_impl.mark_t___lt__, None, mark_t)
mark_t.__le__ = new_instancemethod(_impl.mark_t___le__, None, mark_t)
mark_t.__gt__ = new_instancemethod(_impl.mark_t___gt__, None, mark_t)
mark_t.__ge__ = new_instancemethod(_impl.mark_t___ge__, None, mark_t)
mark_t.has = new_instancemethod(_impl.mark_t_has, None, mark_t)
mark_t.set = new_instancemethod(_impl.mark_t_set, None, mark_t)
mark_t.clear = new_instancemethod(_impl.mark_t_clear, None, mark_t)
mark_t.__iand__ = new_instancemethod(_impl.mark_t___iand__, None, mark_t)
mark_t.__ior__ = new_instancemethod(_impl.mark_t___ior__, None, mark_t)
mark_t.__isub__ = new_instancemethod(_impl.mark_t___isub__, None, mark_t)
mark_t.__ixor__ = new_instancemethod(_impl.mark_t___ixor__, None, mark_t)
mark_t.__and__ = new_instancemethod(_impl.mark_t___and__, None, mark_t)
mark_t.__or__ = new_instancemethod(_impl.mark_t___or__, None, mark_t)
mark_t.__sub__ = new_instancemethod(_impl.mark_t___sub__, None, mark_t)
mark_t.__invert__ = new_instancemethod(_impl.mark_t___invert__, None, mark_t)
mark_t.__xor__ = new_instancemethod(_impl.mark_t___xor__, None, mark_t)
mark_t.__lshift__ = new_instancemethod(_impl.mark_t___lshift__, None, mark_t)
mark_t.__ilshift__ = new_instancemethod(_impl.mark_t___ilshift__, None, mark_t)
mark_t.__rshift__ = new_instancemethod(_impl.mark_t___rshift__, None, mark_t)
mark_t.__irshift__ = new_instancemethod(_impl.mark_t___irshift__, None, mark_t)
mark_t.strip = new_instancemethod(_impl.mark_t_strip, None, mark_t)
mark_t.subset = new_instancemethod(_impl.mark_t_subset, None, mark_t)
mark_t.proper_subset = new_instancemethod(_impl.mark_t_proper_subset, None, mark_t)
mark_t.count = new_instancemethod(_impl.mark_t_count, None, mark_t)
mark_t.max_set = new_instancemethod(_impl.mark_t_max_set, None, mark_t)
mark_t.min_set = new_instancemethod(_impl.mark_t_min_set, None, mark_t)
mark_t.lowest = new_instancemethod(_impl.mark_t_lowest, None, mark_t)
mark_t.is_singleton = new_instancemethod(_impl.mark_t_is_singleton, None, mark_t)
mark_t.has_many = new_instancemethod(_impl.mark_t_has_many, None, mark_t)
mark_t.remove_some = new_instancemethod(_impl.mark_t_remove_some, None, mark_t)
mark_t.sets = new_instancemethod(_impl.mark_t_sets, None, mark_t)
mark_t.as_string = new_instancemethod(_impl.mark_t_as_string, None, mark_t)
mark_t.__repr__ = new_instancemethod(_impl.mark_t___repr__, None, mark_t)
mark_t.__str__ = new_instancemethod(_impl.mark_t___str__, None, mark_t)
mark_t_swigregister = _impl.mark_t_swigregister
mark_t_swigregister(mark_t)

def mark_t_max_accsets() -> "unsigned int":
    return _impl.mark_t_max_accsets()
mark_t_max_accsets = _impl.mark_t_max_accsets

def mark_t_all() -> "spot::acc_cond::mark_t":
    return _impl.mark_t_all()
mark_t_all = _impl.mark_t_all

class acc_code(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    f = staticmethod(_impl.acc_code_f)
    t = staticmethod(_impl.acc_code_t)
    fin = staticmethod(_impl.acc_code_fin)
    fin_neg = staticmethod(_impl.acc_code_fin_neg)
    inf = staticmethod(_impl.acc_code_inf)
    inf_neg = staticmethod(_impl.acc_code_inf_neg)
    buchi = staticmethod(_impl.acc_code_buchi)
    cobuchi = staticmethod(_impl.acc_code_cobuchi)
    generalized_buchi = staticmethod(_impl.acc_code_generalized_buchi)
    generalized_co_buchi = staticmethod(_impl.acc_code_generalized_co_buchi)
    rabin = staticmethod(_impl.acc_code_rabin)
    streett = staticmethod(_impl.acc_code_streett)
    parity = staticmethod(_impl.acc_code_parity)
    parity_max = staticmethod(_impl.acc_code_parity_max)
    parity_max_odd = staticmethod(_impl.acc_code_parity_max_odd)
    parity_max_even = staticmethod(_impl.acc_code_parity_max_even)
    parity_min = staticmethod(_impl.acc_code_parity_min)
    parity_min_odd = staticmethod(_impl.acc_code_parity_min_odd)
    parity_min_even = staticmethod(_impl.acc_code_parity_min_even)
    random = staticmethod(_impl.acc_code_random)

    def __init__(self, *args):
        _impl.acc_code_swiginit(self, _impl.new_acc_code(*args))
    __swig_destroy__ = _impl.delete_acc_code
acc_code.unit_propagation = new_instancemethod(_impl.acc_code_unit_propagation, None, acc_code)
acc_code.has_parity_prefix = new_instancemethod(_impl.acc_code_has_parity_prefix, None, acc_code)
acc_code.is_parity_max_equiv = new_instancemethod(_impl.acc_code_is_parity_max_equiv, None, acc_code)
acc_code.__eq__ = new_instancemethod(_impl.acc_code___eq__, None, acc_code)
acc_code.__lt__ = new_instancemethod(_impl.acc_code___lt__, None, acc_code)
acc_code.__gt__ = new_instancemethod(_impl.acc_code___gt__, None, acc_code)
acc_code.__le__ = new_instancemethod(_impl.acc_code___le__, None, acc_code)
acc_code.__ge__ = new_instancemethod(_impl.acc_code___ge__, None, acc_code)
acc_code.__ne__ = new_instancemethod(_impl.acc_code___ne__, None, acc_code)
acc_code.is_t = new_instancemethod(_impl.acc_code_is_t, None, acc_code)
acc_code.is_f = new_instancemethod(_impl.acc_code_is_f, None, acc_code)
acc_code.__iand__ = new_instancemethod(_impl.acc_code___iand__, None, acc_code)
acc_code.__and__ = new_instancemethod(_impl.acc_code___and__, None, acc_code)
acc_code.__ior__ = new_instancemethod(_impl.acc_code___ior__, None, acc_code)
acc_code.__or__ = new_instancemethod(_impl.acc_code___or__, None, acc_code)
acc_code.__ilshift__ = new_instancemethod(_impl.acc_code___ilshift__, None, acc_code)
acc_code.__lshift__ = new_instancemethod(_impl.acc_code___lshift__, None, acc_code)
acc_code.is_dnf = new_instancemethod(_impl.acc_code_is_dnf, None, acc_code)
acc_code.is_cnf = new_instancemethod(_impl.acc_code_is_cnf, None, acc_code)
acc_code.to_dnf = new_instancemethod(_impl.acc_code_to_dnf, None, acc_code)
acc_code.to_cnf = new_instancemethod(_impl.acc_code_to_cnf, None, acc_code)
acc_code.top_disjuncts = new_instancemethod(_impl.acc_code_top_disjuncts, None, acc_code)
acc_code.top_conjuncts = new_instancemethod(_impl.acc_code_top_conjuncts, None, acc_code)
acc_code.complement = new_instancemethod(_impl.acc_code_complement, None, acc_code)
acc_code.fin_unit = new_instancemethod(_impl.acc_code_fin_unit, None, acc_code)
acc_code.fin_one = new_instancemethod(_impl.acc_code_fin_one, None, acc_code)
acc_code.missing = new_instancemethod(_impl.acc_code_missing, None, acc_code)
acc_code.accepting = new_instancemethod(_impl.acc_code_accepting, None, acc_code)
acc_code.inf_satisfiable = new_instancemethod(_impl.acc_code_inf_satisfiable, None, acc_code)
acc_code.maybe_accepting = new_instancemethod(_impl.acc_code_maybe_accepting, None, acc_code)
acc_code.symmetries = new_instancemethod(_impl.acc_code_symmetries, None, acc_code)
acc_code.remove = new_instancemethod(_impl.acc_code_remove, None, acc_code)
acc_code.strip = new_instancemethod(_impl.acc_code_strip, None, acc_code)
acc_code.force_inf = new_instancemethod(_impl.acc_code_force_inf, None, acc_code)
acc_code.used_sets = new_instancemethod(_impl.acc_code_used_sets, None, acc_code)
acc_code.used_once_sets = new_instancemethod(_impl.acc_code_used_once_sets, None, acc_code)
acc_code.used_inf_fin_sets = new_instancemethod(_impl.acc_code_used_inf_fin_sets, None, acc_code)
acc_code.to_html = new_instancemethod(_impl.acc_code_to_html, None, acc_code)
acc_code.to_text = new_instancemethod(_impl.acc_code_to_text, None, acc_code)
acc_code.to_latex = new_instancemethod(_impl.acc_code_to_latex, None, acc_code)
acc_code.__repr__ = new_instancemethod(_impl.acc_code___repr__, None, acc_code)
acc_code.__str__ = new_instancemethod(_impl.acc_code___str__, None, acc_code)
acc_code_swigregister = _impl.acc_code_swigregister
acc_code_swigregister(acc_code)

def acc_code_f() -> "spot::acc_cond::acc_code":
    return _impl.acc_code_f()
acc_code_f = _impl.acc_code_f

def acc_code_t() -> "spot::acc_cond::acc_code":
    return _impl.acc_code_t()
acc_code_t = _impl.acc_code_t

def acc_code_fin(*args) -> "spot::acc_cond::acc_code":
    return _impl.acc_code_fin(*args)
acc_code_fin = _impl.acc_code_fin

def acc_code_fin_neg(*args) -> "spot::acc_cond::acc_code":
    return _impl.acc_code_fin_neg(*args)
acc_code_fin_neg = _impl.acc_code_fin_neg

def acc_code_inf(*args) -> "spot::acc_cond::acc_code":
    return _impl.acc_code_inf(*args)
acc_code_inf = _impl.acc_code_inf

def acc_code_inf_neg(*args) -> "spot::acc_cond::acc_code":
    return _impl.acc_code_inf_neg(*args)
acc_code_inf_neg = _impl.acc_code_inf_neg

def acc_code_buchi() -> "spot::acc_cond::acc_code":
    return _impl.acc_code_buchi()
acc_code_buchi = _impl.acc_code_buchi

def acc_code_cobuchi() -> "spot::acc_cond::acc_code":
    return _impl.acc_code_cobuchi()
acc_code_cobuchi = _impl.acc_code_cobuchi

def acc_code_generalized_buchi(n: 'unsigned int') -> "spot::acc_cond::acc_code":
    return _impl.acc_code_generalized_buchi(n)
acc_code_generalized_buchi = _impl.acc_code_generalized_buchi

def acc_code_generalized_co_buchi(n: 'unsigned int') -> "spot::acc_cond::acc_code":
    return _impl.acc_code_generalized_co_buchi(n)
acc_code_generalized_co_buchi = _impl.acc_code_generalized_co_buchi

def acc_code_rabin(n: 'unsigned int') -> "spot::acc_cond::acc_code":
    return _impl.acc_code_rabin(n)
acc_code_rabin = _impl.acc_code_rabin

def acc_code_streett(n: 'unsigned int') -> "spot::acc_cond::acc_code":
    return _impl.acc_code_streett(n)
acc_code_streett = _impl.acc_code_streett

def acc_code_parity(is_max: 'bool', is_odd: 'bool', sets: 'unsigned int') -> "spot::acc_cond::acc_code":
    return _impl.acc_code_parity(is_max, is_odd, sets)
acc_code_parity = _impl.acc_code_parity

def acc_code_parity_max(is_odd: 'bool', sets: 'unsigned int') -> "spot::acc_cond::acc_code":
    return _impl.acc_code_parity_max(is_odd, sets)
acc_code_parity_max = _impl.acc_code_parity_max

def acc_code_parity_max_odd(sets: 'unsigned int') -> "spot::acc_cond::acc_code":
    return _impl.acc_code_parity_max_odd(sets)
acc_code_parity_max_odd = _impl.acc_code_parity_max_odd

def acc_code_parity_max_even(sets: 'unsigned int') -> "spot::acc_cond::acc_code":
    return _impl.acc_code_parity_max_even(sets)
acc_code_parity_max_even = _impl.acc_code_parity_max_even

def acc_code_parity_min(is_odd: 'bool', sets: 'unsigned int') -> "spot::acc_cond::acc_code":
    return _impl.acc_code_parity_min(is_odd, sets)
acc_code_parity_min = _impl.acc_code_parity_min

def acc_code_parity_min_odd(sets: 'unsigned int') -> "spot::acc_cond::acc_code":
    return _impl.acc_code_parity_min_odd(sets)
acc_code_parity_min_odd = _impl.acc_code_parity_min_odd

def acc_code_parity_min_even(sets: 'unsigned int') -> "spot::acc_cond::acc_code":
    return _impl.acc_code_parity_min_even(sets)
acc_code_parity_min_even = _impl.acc_code_parity_min_even

def acc_code_random(n: 'unsigned int', reuse: 'double'=0.0) -> "spot::acc_cond::acc_code":
    return _impl.acc_code_random(n, reuse)
acc_code_random = _impl.acc_code_random

class rs_pair(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, fin: 'mark_t', inf: 'mark_t'):
        _impl.rs_pair_swiginit(self, _impl.new_rs_pair(fin, inf))
    fin = _swig_property(_impl.rs_pair_fin_get, _impl.rs_pair_fin_set)
    inf = _swig_property(_impl.rs_pair_inf_get, _impl.rs_pair_inf_set)
    __swig_destroy__ = _impl.delete_rs_pair
rs_pair.__eq__ = new_instancemethod(_impl.rs_pair___eq__, None, rs_pair)
rs_pair.__ne__ = new_instancemethod(_impl.rs_pair___ne__, None, rs_pair)
rs_pair.__lt__ = new_instancemethod(_impl.rs_pair___lt__, None, rs_pair)
rs_pair.__le__ = new_instancemethod(_impl.rs_pair___le__, None, rs_pair)
rs_pair.__gt__ = new_instancemethod(_impl.rs_pair___gt__, None, rs_pair)
rs_pair.__ge__ = new_instancemethod(_impl.rs_pair___ge__, None, rs_pair)
rs_pair.__repr__ = new_instancemethod(_impl.rs_pair___repr__, None, rs_pair)
rs_pair_swigregister = _impl.rs_pair_swigregister
rs_pair_swigregister(rs_pair)

class rs_pairs_view(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _impl.rs_pairs_view_swiginit(self, _impl.new_rs_pairs_view(*args))
    __swig_destroy__ = _impl.delete_rs_pairs_view
rs_pairs_view.infs = new_instancemethod(_impl.rs_pairs_view_infs, None, rs_pairs_view)
rs_pairs_view.fins = new_instancemethod(_impl.rs_pairs_view_fins, None, rs_pairs_view)
rs_pairs_view.fins_alone = new_instancemethod(_impl.rs_pairs_view_fins_alone, None, rs_pairs_view)
rs_pairs_view.infs_alone = new_instancemethod(_impl.rs_pairs_view_infs_alone, None, rs_pairs_view)
rs_pairs_view.paired_with_fin = new_instancemethod(_impl.rs_pairs_view_paired_with_fin, None, rs_pairs_view)
rs_pairs_view.pairs = new_instancemethod(_impl.rs_pairs_view_pairs, None, rs_pairs_view)
rs_pairs_view_swigregister = _impl.rs_pairs_view_swigregister
rs_pairs_view_swigregister(rs_pairs_view)


def __lshift__(*args) -> "std::ostream &":
    return _impl.__lshift__(*args)
__lshift__ = _impl.__lshift__
class mark_iterator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _impl.mark_iterator_swiginit(self, _impl.new_mark_iterator(*args))
    __swig_destroy__ = _impl.delete_mark_iterator
mark_iterator.__eq__ = new_instancemethod(_impl.mark_iterator___eq__, None, mark_iterator)
mark_iterator.__ne__ = new_instancemethod(_impl.mark_iterator___ne__, None, mark_iterator)
mark_iterator.__ref__ = new_instancemethod(_impl.mark_iterator___ref__, None, mark_iterator)
mark_iterator_swigregister = _impl.mark_iterator_swigregister
mark_iterator_swigregister(mark_iterator)

class mark_container(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, m: 'mark_t'):
        _impl.mark_container_swiginit(self, _impl.new_mark_container(m))
    __swig_destroy__ = _impl.delete_mark_container
mark_container.begin = new_instancemethod(_impl.mark_container_begin, None, mark_container)
mark_container.end = new_instancemethod(_impl.mark_container_end, None, mark_container)
mark_container.__iter__ = new_instancemethod(_impl.mark_container___iter__, None, mark_container)
mark_container_swigregister = _impl.mark_container_swigregister
mark_container_swigregister(mark_container)

class pair_bool_mark(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _impl.pair_bool_mark_swiginit(self, _impl.new_pair_bool_mark(*args))
    first = _swig_property(_impl.pair_bool_mark_first_get, _impl.pair_bool_mark_first_set)
    second = _swig_property(_impl.pair_bool_mark_second_get, _impl.pair_bool_mark_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _impl.delete_pair_bool_mark
pair_bool_mark_swigregister = _impl.pair_bool_mark_swigregister
pair_bool_mark_swigregister(pair_bool_mark)

class state(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
state.compare = new_instancemethod(_impl.state_compare, None, state)
state.hash = new_instancemethod(_impl.state_hash, None, state)
state.clone = new_instancemethod(_impl.state_clone, None, state)
state.destroy = new_instancemethod(_impl.state_destroy, None, state)
state_swigregister = _impl.state_swigregister
state_swigregister(state)

class state_ptr_less_than(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _impl.state_ptr_less_than_swiginit(self, _impl.new_state_ptr_less_than())
    __swig_destroy__ = _impl.delete_state_ptr_less_than
state_ptr_less_than.__call__ = new_instancemethod(_impl.state_ptr_less_than___call__, None, state_ptr_less_than)
state_ptr_less_than_swigregister = _impl.state_ptr_less_than_swigregister
state_ptr_less_than_swigregister(state_ptr_less_than)

class state_ptr_equal(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _impl.state_ptr_equal_swiginit(self, _impl.new_state_ptr_equal())
    __swig_destroy__ = _impl.delete_state_ptr_equal
state_ptr_equal.__call__ = new_instancemethod(_impl.state_ptr_equal___call__, None, state_ptr_equal)
state_ptr_equal_swigregister = _impl.state_ptr_equal_swigregister
state_ptr_equal_swigregister(state_ptr_equal)

class state_ptr_hash(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _impl.state_ptr_hash_swiginit(self, _impl.new_state_ptr_hash())
    __swig_destroy__ = _impl.delete_state_ptr_hash
state_ptr_hash.__call__ = new_instancemethod(_impl.state_ptr_hash___call__, None, state_ptr_hash)
state_ptr_hash_swigregister = _impl.state_ptr_hash_swigregister
state_ptr_hash_swigregister(state_ptr_hash)

class state_unicity_table(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _impl.delete_state_unicity_table

    def __init__(self):
        _impl.state_unicity_table_swiginit(self, _impl.new_state_unicity_table())
state_unicity_table.__call__ = new_instancemethod(_impl.state_unicity_table___call__, None, state_unicity_table)
state_unicity_table.is_new = new_instancemethod(_impl.state_unicity_table_is_new, None, state_unicity_table)
state_unicity_table.size = new_instancemethod(_impl.state_unicity_table_size, None, state_unicity_table)
state_unicity_table_swigregister = _impl.state_unicity_table_swigregister
state_unicity_table_swigregister(state_unicity_table)


def shared_state_deleter(s: 'state') -> "void":
    return _impl.shared_state_deleter(s)
shared_state_deleter = _impl.shared_state_deleter
class state_shared_ptr_less_than(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _impl.state_shared_ptr_less_than_swiginit(self, _impl.new_state_shared_ptr_less_than())
    __swig_destroy__ = _impl.delete_state_shared_ptr_less_than
state_shared_ptr_less_than.__call__ = new_instancemethod(_impl.state_shared_ptr_less_than___call__, None, state_shared_ptr_less_than)
state_shared_ptr_less_than_swigregister = _impl.state_shared_ptr_less_than_swigregister
state_shared_ptr_less_than_swigregister(state_shared_ptr_less_than)

class state_shared_ptr_equal(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _impl.state_shared_ptr_equal_swiginit(self, _impl.new_state_shared_ptr_equal())
    __swig_destroy__ = _impl.delete_state_shared_ptr_equal
state_shared_ptr_equal.__call__ = new_instancemethod(_impl.state_shared_ptr_equal___call__, None, state_shared_ptr_equal)
state_shared_ptr_equal_swigregister = _impl.state_shared_ptr_equal_swigregister
state_shared_ptr_equal_swigregister(state_shared_ptr_equal)

class state_shared_ptr_hash(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _impl.state_shared_ptr_hash_swiginit(self, _impl.new_state_shared_ptr_hash())
    __swig_destroy__ = _impl.delete_state_shared_ptr_hash
state_shared_ptr_hash.__call__ = new_instancemethod(_impl.state_shared_ptr_hash___call__, None, state_shared_ptr_hash)
state_shared_ptr_hash_swigregister = _impl.state_shared_ptr_hash_swigregister
state_shared_ptr_hash_swigregister(state_shared_ptr_hash)

class twa_succ_iterator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _impl.delete_twa_succ_iterator
twa_succ_iterator.first = new_instancemethod(_impl.twa_succ_iterator_first, None, twa_succ_iterator)
twa_succ_iterator.next = new_instancemethod(_impl.twa_succ_iterator_next, None, twa_succ_iterator)
twa_succ_iterator.done = new_instancemethod(_impl.twa_succ_iterator_done, None, twa_succ_iterator)
twa_succ_iterator.dst = new_instancemethod(_impl.twa_succ_iterator_dst, None, twa_succ_iterator)
twa_succ_iterator.cond = new_instancemethod(_impl.twa_succ_iterator_cond, None, twa_succ_iterator)
twa_succ_iterator.acc = new_instancemethod(_impl.twa_succ_iterator_acc, None, twa_succ_iterator)
twa_succ_iterator_swigregister = _impl.twa_succ_iterator_swigregister
twa_succ_iterator_swigregister(twa_succ_iterator)

class succ_iterator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, it: 'twa_succ_iterator'):
        _impl.succ_iterator_swiginit(self, _impl.new_succ_iterator(it))
    __swig_destroy__ = _impl.delete_succ_iterator
succ_iterator.__eq__ = new_instancemethod(_impl.succ_iterator___eq__, None, succ_iterator)
succ_iterator.__ne__ = new_instancemethod(_impl.succ_iterator___ne__, None, succ_iterator)
succ_iterator.__ref__ = new_instancemethod(_impl.succ_iterator___ref__, None, succ_iterator)
succ_iterator_swigregister = _impl.succ_iterator_swigregister
succ_iterator_swigregister(succ_iterator)

class twa(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _impl.delete_twa

    def prop_deterministic(self, *args) -> "spot::trival":

        from warnings import warn
        warn("use prop_universal() instead of prop_deterministic()",
             DeprecationWarning)


        return _impl.twa_prop_deterministic(self, *args)

twa.get_init_state = new_instancemethod(_impl.twa_get_init_state, None, twa)
twa.succ_iter = new_instancemethod(_impl.twa_succ_iter, None, twa)
twa.release_iter = new_instancemethod(_impl.twa_release_iter, None, twa)
twa.get_dict = new_instancemethod(_impl.twa_get_dict, None, twa)
twa.register_ap = new_instancemethod(_impl.twa_register_ap, None, twa)
twa.unregister_ap = new_instancemethod(_impl.twa_unregister_ap, None, twa)
twa.register_aps_from_dict = new_instancemethod(_impl.twa_register_aps_from_dict, None, twa)
twa.ap = new_instancemethod(_impl.twa_ap, None, twa)
twa.ap_vars = new_instancemethod(_impl.twa_ap_vars, None, twa)
twa.format_state = new_instancemethod(_impl.twa_format_state, None, twa)
twa.project_state = new_instancemethod(_impl.twa_project_state, None, twa)
twa.acc = new_instancemethod(_impl.twa_acc, None, twa)
twa.is_empty = new_instancemethod(_impl.twa_is_empty, None, twa)
twa.accepting_run = new_instancemethod(_impl.twa_accepting_run, None, twa)
twa.accepting_word = new_instancemethod(_impl.twa_accepting_word, None, twa)
twa.intersects = new_instancemethod(_impl.twa_intersects, None, twa)
twa.intersecting_run = new_instancemethod(_impl.twa_intersecting_run, None, twa)
twa.intersecting_word = new_instancemethod(_impl.twa_intersecting_word, None, twa)
twa.exclusive_run = new_instancemethod(_impl.twa_exclusive_run, None, twa)
twa.exclusive_word = new_instancemethod(_impl.twa_exclusive_word, None, twa)
twa.num_sets = new_instancemethod(_impl.twa_num_sets, None, twa)
twa.get_acceptance = new_instancemethod(_impl.twa_get_acceptance, None, twa)
twa.set_acceptance = new_instancemethod(_impl.twa_set_acceptance, None, twa)
twa.copy_acceptance_of = new_instancemethod(_impl.twa_copy_acceptance_of, None, twa)
twa.copy_ap_of = new_instancemethod(_impl.twa_copy_ap_of, None, twa)
twa.set_generalized_buchi = new_instancemethod(_impl.twa_set_generalized_buchi, None, twa)
twa.set_generalized_co_buchi = new_instancemethod(_impl.twa_set_generalized_co_buchi, None, twa)
twa.set_buchi = new_instancemethod(_impl.twa_set_buchi, None, twa)
twa.set_co_buchi = new_instancemethod(_impl.twa_set_co_buchi, None, twa)
twa.release_named_properties = new_instancemethod(_impl.twa_release_named_properties, None, twa)
twa.prop_state_acc = new_instancemethod(_impl.twa_prop_state_acc, None, twa)
twa.is_sba = new_instancemethod(_impl.twa_is_sba, None, twa)
twa.prop_inherently_weak = new_instancemethod(_impl.twa_prop_inherently_weak, None, twa)
twa.prop_terminal = new_instancemethod(_impl.twa_prop_terminal, None, twa)
twa.prop_weak = new_instancemethod(_impl.twa_prop_weak, None, twa)
twa.prop_very_weak = new_instancemethod(_impl.twa_prop_very_weak, None, twa)
twa.prop_complete = new_instancemethod(_impl.twa_prop_complete, None, twa)
twa.prop_universal = new_instancemethod(_impl.twa_prop_universal, None, twa)
twa.prop_unambiguous = new_instancemethod(_impl.twa_prop_unambiguous, None, twa)
twa.prop_semi_deterministic = new_instancemethod(_impl.twa_prop_semi_deterministic, None, twa)
twa.prop_stutter_invariant = new_instancemethod(_impl.twa_prop_stutter_invariant, None, twa)
twa.prop_copy = new_instancemethod(_impl.twa_prop_copy, None, twa)
twa.prop_keep = new_instancemethod(_impl.twa_prop_keep, None, twa)
twa.prop_reset = new_instancemethod(_impl.twa_prop_reset, None, twa)
twa.set_name = new_instancemethod(_impl.twa_set_name, None, twa)
twa.get_name = new_instancemethod(_impl.twa_get_name, None, twa)
twa.set_state_names = new_instancemethod(_impl.twa_set_state_names, None, twa)
twa.get_state_names = new_instancemethod(_impl.twa_get_state_names, None, twa)
twa.set_product_states = new_instancemethod(_impl.twa_set_product_states, None, twa)
twa.get_product_states = new_instancemethod(_impl.twa_get_product_states, None, twa)
twa.highlight_state = new_instancemethod(_impl.twa_highlight_state, None, twa)
twa.highlight_edge = new_instancemethod(_impl.twa_highlight_edge, None, twa)
twa_swigregister = _impl.twa_swigregister
twa_swigregister(twa)


def create_atomic_prop_set(n: 'unsigned int') -> "spot::atomic_prop_set":
    return _impl.create_atomic_prop_set(n)
create_atomic_prop_set = _impl.create_atomic_prop_set

def atomic_prop_collect(f: 'formula', s: 'atomic_prop_set'=None) -> "spot::atomic_prop_set *":
    return _impl.atomic_prop_collect(f, s)
atomic_prop_collect = _impl.atomic_prop_collect

def atomic_prop_collect_as_bdd(f: 'formula', a: 'spot::twa_ptr const &') -> "bdd":
    return _impl.atomic_prop_collect_as_bdd(f, a)
atomic_prop_collect_as_bdd = _impl.atomic_prop_collect_as_bdd
class language_containment_checker(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _impl.language_containment_checker_swiginit(self, _impl.new_language_containment_checker(*args))
    __swig_destroy__ = _impl.delete_language_containment_checker
language_containment_checker.clear = new_instancemethod(_impl.language_containment_checker_clear, None, language_containment_checker)
language_containment_checker.contained = new_instancemethod(_impl.language_containment_checker_contained, None, language_containment_checker)
language_containment_checker.neg_contained = new_instancemethod(_impl.language_containment_checker_neg_contained, None, language_containment_checker)
language_containment_checker.contained_neg = new_instancemethod(_impl.language_containment_checker_contained_neg, None, language_containment_checker)
language_containment_checker.equal = new_instancemethod(_impl.language_containment_checker_equal, None, language_containment_checker)
language_containment_checker_swigregister = _impl.language_containment_checker_swigregister
language_containment_checker_swigregister(language_containment_checker)


def print_dot_psl(os: 'ostream', f: 'formula') -> "std::ostream &":
    return _impl.print_dot_psl(os, f)
print_dot_psl = _impl.print_dot_psl

def negative_normal_form(f: 'formula', negated: 'bool'=False) -> "spot::formula":
    return _impl.negative_normal_form(f, negated)
negative_normal_form = _impl.negative_normal_form

def print_psl(os: 'ostream', f: 'formula', full_parent: 'bool'=False) -> "std::ostream &":
    return _impl.print_psl(os, f, full_parent)
print_psl = _impl.print_psl

def str_psl(f: 'formula', full_parent: 'bool'=False) -> "std::string":
    return _impl.str_psl(f, full_parent)
str_psl = _impl.str_psl

def print_utf8_psl(os: 'ostream', f: 'formula', full_parent: 'bool'=False) -> "std::ostream &":
    return _impl.print_utf8_psl(os, f, full_parent)
print_utf8_psl = _impl.print_utf8_psl

def str_utf8_psl(f: 'formula', full_parent: 'bool'=False) -> "std::string":
    return _impl.str_utf8_psl(f, full_parent)
str_utf8_psl = _impl.str_utf8_psl

def print_sere(os: 'ostream', f: 'formula', full_parent: 'bool'=False) -> "std::ostream &":
    return _impl.print_sere(os, f, full_parent)
print_sere = _impl.print_sere

def str_sere(f: 'formula', full_parent: 'bool'=False) -> "std::string":
    return _impl.str_sere(f, full_parent)
str_sere = _impl.str_sere

def print_utf8_sere(os: 'ostream', f: 'formula', full_parent: 'bool'=False) -> "std::ostream &":
    return _impl.print_utf8_sere(os, f, full_parent)
print_utf8_sere = _impl.print_utf8_sere

def str_utf8_sere(f: 'formula', full_parent: 'bool'=False) -> "std::string":
    return _impl.str_utf8_sere(f, full_parent)
str_utf8_sere = _impl.str_utf8_sere

def print_spin_ltl(os: 'ostream', f: 'formula', full_parent: 'bool'=False) -> "std::ostream &":
    return _impl.print_spin_ltl(os, f, full_parent)
print_spin_ltl = _impl.print_spin_ltl

def str_spin_ltl(f: 'formula', full_parent: 'bool'=False) -> "std::string":
    return _impl.str_spin_ltl(f, full_parent)
str_spin_ltl = _impl.str_spin_ltl

def print_wring_ltl(os: 'ostream', f: 'formula') -> "std::ostream &":
    return _impl.print_wring_ltl(os, f)
print_wring_ltl = _impl.print_wring_ltl

def str_wring_ltl(f: 'formula') -> "std::string":
    return _impl.str_wring_ltl(f)
str_wring_ltl = _impl.str_wring_ltl

def print_latex_psl(os: 'ostream', f: 'formula', full_parent: 'bool'=False) -> "std::ostream &":
    return _impl.print_latex_psl(os, f, full_parent)
print_latex_psl = _impl.print_latex_psl

def str_latex_psl(f: 'formula', full_parent: 'bool'=False) -> "std::string":
    return _impl.str_latex_psl(f, full_parent)
str_latex_psl = _impl.str_latex_psl

def print_latex_sere(os: 'ostream', f: 'formula', full_parent: 'bool'=False) -> "std::ostream &":
    return _impl.print_latex_sere(os, f, full_parent)
print_latex_sere = _impl.print_latex_sere

def str_latex_sere(f: 'formula', full_parent: 'bool'=False) -> "std::string":
    return _impl.str_latex_sere(f, full_parent)
str_latex_sere = _impl.str_latex_sere

def print_sclatex_psl(os: 'ostream', f: 'formula', full_parent: 'bool'=False) -> "std::ostream &":
    return _impl.print_sclatex_psl(os, f, full_parent)
print_sclatex_psl = _impl.print_sclatex_psl

def str_sclatex_psl(f: 'formula', full_parent: 'bool'=False) -> "std::string":
    return _impl.str_sclatex_psl(f, full_parent)
str_sclatex_psl = _impl.str_sclatex_psl

def print_sclatex_sere(os: 'ostream', f: 'formula', full_parent: 'bool'=False) -> "std::ostream &":
    return _impl.print_sclatex_sere(os, f, full_parent)
print_sclatex_sere = _impl.print_sclatex_sere

def str_sclatex_sere(f: 'formula', full_parent: 'bool'=False) -> "std::string":
    return _impl.str_sclatex_sere(f, full_parent)
str_sclatex_sere = _impl.str_sclatex_sere

def print_lbt_ltl(os: 'ostream', f: 'formula') -> "std::ostream &":
    return _impl.print_lbt_ltl(os, f)
print_lbt_ltl = _impl.print_lbt_ltl

def str_lbt_ltl(f: 'formula') -> "std::string":
    return _impl.str_lbt_ltl(f)
str_lbt_ltl = _impl.str_lbt_ltl
class tl_simplifier_options(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _impl.tl_simplifier_options_swiginit(self, _impl.new_tl_simplifier_options(*args))
    reduce_basics = _swig_property(_impl.tl_simplifier_options_reduce_basics_get, _impl.tl_simplifier_options_reduce_basics_set)
    synt_impl = _swig_property(_impl.tl_simplifier_options_synt_impl_get, _impl.tl_simplifier_options_synt_impl_set)
    event_univ = _swig_property(_impl.tl_simplifier_options_event_univ_get, _impl.tl_simplifier_options_event_univ_set)
    containment_checks = _swig_property(_impl.tl_simplifier_options_containment_checks_get, _impl.tl_simplifier_options_containment_checks_set)
    containment_checks_stronger = _swig_property(_impl.tl_simplifier_options_containment_checks_stronger_get, _impl.tl_simplifier_options_containment_checks_stronger_set)
    nenoform_stop_on_boolean = _swig_property(_impl.tl_simplifier_options_nenoform_stop_on_boolean_get, _impl.tl_simplifier_options_nenoform_stop_on_boolean_set)
    reduce_size_strictly = _swig_property(_impl.tl_simplifier_options_reduce_size_strictly_get, _impl.tl_simplifier_options_reduce_size_strictly_set)
    boolean_to_isop = _swig_property(_impl.tl_simplifier_options_boolean_to_isop_get, _impl.tl_simplifier_options_boolean_to_isop_set)
    favor_event_univ = _swig_property(_impl.tl_simplifier_options_favor_event_univ_get, _impl.tl_simplifier_options_favor_event_univ_set)
    keep_top_xor = _swig_property(_impl.tl_simplifier_options_keep_top_xor_get, _impl.tl_simplifier_options_keep_top_xor_set)
    __swig_destroy__ = _impl.delete_tl_simplifier_options
tl_simplifier_options_swigregister = _impl.tl_simplifier_options_swigregister
tl_simplifier_options_swigregister(tl_simplifier_options)

class tl_simplifier(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _impl.tl_simplifier_swiginit(self, _impl.new_tl_simplifier(*args))
    __swig_destroy__ = _impl.delete_tl_simplifier
tl_simplifier.simplify = new_instancemethod(_impl.tl_simplifier_simplify, None, tl_simplifier)
tl_simplifier.negative_normal_form = new_instancemethod(_impl.tl_simplifier_negative_normal_form, None, tl_simplifier)
tl_simplifier.syntactic_implication = new_instancemethod(_impl.tl_simplifier_syntactic_implication, None, tl_simplifier)
tl_simplifier.syntactic_implication_neg = new_instancemethod(_impl.tl_simplifier_syntactic_implication_neg, None, tl_simplifier)
tl_simplifier.are_equivalent = new_instancemethod(_impl.tl_simplifier_are_equivalent, None, tl_simplifier)
tl_simplifier.implication = new_instancemethod(_impl.tl_simplifier_implication, None, tl_simplifier)
tl_simplifier.as_bdd = new_instancemethod(_impl.tl_simplifier_as_bdd, None, tl_simplifier)
tl_simplifier.clear_as_bdd_cache = new_instancemethod(_impl.tl_simplifier_clear_as_bdd_cache, None, tl_simplifier)
tl_simplifier.clear_caches = new_instancemethod(_impl.tl_simplifier_clear_caches, None, tl_simplifier)
tl_simplifier.get_dict = new_instancemethod(_impl.tl_simplifier_get_dict, None, tl_simplifier)
tl_simplifier.star_normal_form = new_instancemethod(_impl.tl_simplifier_star_normal_form, None, tl_simplifier)
tl_simplifier.boolean_to_isop = new_instancemethod(_impl.tl_simplifier_boolean_to_isop, None, tl_simplifier)
tl_simplifier.print_stats = new_instancemethod(_impl.tl_simplifier_print_stats, None, tl_simplifier)
tl_simplifier_swigregister = _impl.tl_simplifier_swigregister
tl_simplifier_swigregister(tl_simplifier)

class unabbreviator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _impl.unabbreviator_swiginit(self, _impl.new_unabbreviator(*args))
    __swig_destroy__ = _impl.delete_unabbreviator
unabbreviator.run = new_instancemethod(_impl.unabbreviator_run, None, unabbreviator)
unabbreviator_swigregister = _impl.unabbreviator_swigregister
unabbreviator_swigregister(unabbreviator)
cvar = _impl.cvar
default_unabbrev_string = cvar.default_unabbrev_string


def unabbreviate(*args) -> "spot::formula":
    return _impl.unabbreviate(*args)
unabbreviate = _impl.unabbreviate
class random_formula(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, proba_size: 'unsigned int', ap: 'atomic_prop_set'):
        _impl.random_formula_swiginit(self, _impl.new_random_formula(proba_size, ap))
    __swig_destroy__ = _impl.delete_random_formula
random_formula.ap = new_instancemethod(_impl.random_formula_ap, None, random_formula)
random_formula.generate = new_instancemethod(_impl.random_formula_generate, None, random_formula)
random_formula.dump_priorities = new_instancemethod(_impl.random_formula_dump_priorities, None, random_formula)
random_formula.parse_options = new_instancemethod(_impl.random_formula_parse_options, None, random_formula)
random_formula_swigregister = _impl.random_formula_swigregister
random_formula_swigregister(random_formula)

class random_ltl(random_formula):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, ap: 'atomic_prop_set'):
        _impl.random_ltl_swiginit(self, _impl.new_random_ltl(ap))
    __swig_destroy__ = _impl.delete_random_ltl
random_ltl_swigregister = _impl.random_ltl_swigregister
random_ltl_swigregister(random_ltl)

class random_boolean(random_formula):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, ap: 'atomic_prop_set'):
        _impl.random_boolean_swiginit(self, _impl.new_random_boolean(ap))
    __swig_destroy__ = _impl.delete_random_boolean
random_boolean_swigregister = _impl.random_boolean_swigregister
random_boolean_swigregister(random_boolean)

class random_sere(random_formula):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, ap: 'atomic_prop_set'):
        _impl.random_sere_swiginit(self, _impl.new_random_sere(ap))
    rb = _swig_property(_impl.random_sere_rb_get, _impl.random_sere_rb_set)
    __swig_destroy__ = _impl.delete_random_sere
random_sere_swigregister = _impl.random_sere_swigregister
random_sere_swigregister(random_sere)

class random_psl(random_ltl):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, ap: 'atomic_prop_set'):
        _impl.random_psl_swiginit(self, _impl.new_random_psl(ap))
    rs = _swig_property(_impl.random_psl_rs_get, _impl.random_psl_rs_set)
    __swig_destroy__ = _impl.delete_random_psl
random_psl_swigregister = _impl.random_psl_swigregister
random_psl_swigregister(random_psl)

class randltlgenerator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Bool = _impl.randltlgenerator_Bool
    LTL = _impl.randltlgenerator_LTL
    SERE = _impl.randltlgenerator_SERE
    PSL = _impl.randltlgenerator_PSL
    MAX_TRIALS = _impl.randltlgenerator_MAX_TRIALS

    def __init__(self, *args):
        _impl.randltlgenerator_swiginit(self, _impl.new_randltlgenerator(*args))
    __swig_destroy__ = _impl.delete_randltlgenerator
randltlgenerator.next = new_instancemethod(_impl.randltlgenerator_next, None, randltlgenerator)
randltlgenerator.dump_ltl_priorities = new_instancemethod(_impl.randltlgenerator_dump_ltl_priorities, None, randltlgenerator)
randltlgenerator.dump_bool_priorities = new_instancemethod(_impl.randltlgenerator_dump_bool_priorities, None, randltlgenerator)
randltlgenerator.dump_psl_priorities = new_instancemethod(_impl.randltlgenerator_dump_psl_priorities, None, randltlgenerator)
randltlgenerator.dump_sere_priorities = new_instancemethod(_impl.randltlgenerator_dump_sere_priorities, None, randltlgenerator)
randltlgenerator.dump_sere_bool_priorities = new_instancemethod(_impl.randltlgenerator_dump_sere_bool_priorities, None, randltlgenerator)
randltlgenerator.remove_some_props = new_instancemethod(_impl.randltlgenerator_remove_some_props, None, randltlgenerator)
randltlgenerator.GF_n = new_instancemethod(_impl.randltlgenerator_GF_n, None, randltlgenerator)
randltlgenerator_swigregister = _impl.randltlgenerator_swigregister
randltlgenerator_swigregister(randltlgenerator)


def length(f: 'formula') -> "int":
    return _impl.length(f)
length = _impl.length

def length_boolone(f: 'formula') -> "int":
    return _impl.length_boolone(f)
length_boolone = _impl.length_boolone

def from_ltlf(*args) -> "spot::formula":
    return _impl.from_ltlf(*args)
from_ltlf = _impl.from_ltlf
prcheck_Auto = _impl.prcheck_Auto
prcheck_via_CoBuchi = _impl.prcheck_via_CoBuchi
prcheck_via_Rabin = _impl.prcheck_via_Rabin
prcheck_via_Parity = _impl.prcheck_via_Parity

def is_persistence(*args) -> "bool":
    return _impl.is_persistence(*args)
is_persistence = _impl.is_persistence

def is_recurrence(*args) -> "bool":
    return _impl.is_recurrence(*args)
is_recurrence = _impl.is_recurrence
ocheck_Auto = _impl.ocheck_Auto
ocheck_via_CoBuchi = _impl.ocheck_via_CoBuchi
ocheck_via_Rabin = _impl.ocheck_via_Rabin
ocheck_via_WDBA = _impl.ocheck_via_WDBA

def is_obligation(*args) -> "bool":
    return _impl.is_obligation(*args)
is_obligation = _impl.is_obligation

def mp_class(*args) -> "std::string":
    return _impl.mp_class(*args)
mp_class = _impl.mp_class

def nesting_depth(*args) -> "unsigned int":
    return _impl.nesting_depth(*args)
nesting_depth = _impl.nesting_depth

def is_liveness(f: 'formula') -> "bool":
    return _impl.is_liveness(f)
is_liveness = _impl.is_liveness

def remove_x(f: 'formula') -> "spot::formula":
    return _impl.remove_x(f)
remove_x = _impl.remove_x
Abc = _impl.Abc
Pnn = _impl.Pnn

def relabel(f: 'formula', style: 'spot::relabeling_style', m: 'relabeling_map'=None) -> "spot::formula":
    return _impl.relabel(f, style, m)
relabel = _impl.relabel

def relabel_bse(f: 'formula', style: 'spot::relabeling_style', m: 'relabeling_map'=None) -> "spot::formula":
    return _impl.relabel_bse(f, style, m)
relabel_bse = _impl.relabel_bse

def relabel_apply(f: 'formula', m: 'relabeling_map') -> "spot::formula":
    return _impl.relabel_apply(f, m)
relabel_apply = _impl.relabel_apply
class taa_tgba(twa):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _impl.delete_taa_tgba
taa_tgba.add_condition = new_instancemethod(_impl.taa_tgba_add_condition, None, taa_tgba)
taa_tgba.get_init_state = new_instancemethod(_impl.taa_tgba_get_init_state, None, taa_tgba)
taa_tgba_swigregister = _impl.taa_tgba_swigregister
taa_tgba_swigregister(taa_tgba)

class set_state(state):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, s: 'spot::taa_tgba::state_set const *', delete_me: 'bool'=False):
        _impl.set_state_swiginit(self, _impl.new_set_state(s, delete_me))
    __swig_destroy__ = _impl.delete_set_state
set_state.clone = new_instancemethod(_impl.set_state_clone, None, set_state)
set_state.get_state = new_instancemethod(_impl.set_state_get_state, None, set_state)
set_state_swigregister = _impl.set_state_swigregister
set_state_swigregister(set_state)

class taa_succ_iterator(twa_succ_iterator):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, s: 'spot::taa_tgba::state_set const *', acc: 'acc_cond'):
        _impl.taa_succ_iterator_swiginit(self, _impl.new_taa_succ_iterator(s, acc))
    __swig_destroy__ = _impl.delete_taa_succ_iterator
taa_succ_iterator.dst = new_instancemethod(_impl.taa_succ_iterator_dst, None, taa_succ_iterator)
taa_succ_iterator_swigregister = _impl.taa_succ_iterator_swigregister
taa_succ_iterator_swigregister(taa_succ_iterator)

class taa_tgba_string(taa_tgba):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _impl.delete_taa_tgba_string
taa_tgba_string_swigregister = _impl.taa_tgba_string_swigregister
taa_tgba_string_swigregister(taa_tgba_string)


def make_taa_tgba_string(dict: 'spot::bdd_dict_ptr const &') -> "spot::taa_tgba_string_ptr":
    return _impl.make_taa_tgba_string(dict)
make_taa_tgba_string = _impl.make_taa_tgba_string
class taa_tgba_formula(taa_tgba):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _impl.delete_taa_tgba_formula
taa_tgba_formula_swigregister = _impl.taa_tgba_formula_swigregister
taa_tgba_formula_swigregister(taa_tgba_formula)


def make_taa_tgba_formula(dict: 'spot::bdd_dict_ptr const &') -> "spot::taa_tgba_formula_ptr":
    return _impl.make_taa_tgba_formula(dict)
make_taa_tgba_formula = _impl.make_taa_tgba_formula
class state_product(state):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, left: 'state', right: 'state', pool: 'fixed_size_pool *'):
        _impl.state_product_swiginit(self, _impl.new_state_product(left, right, pool))
state_product.left = new_instancemethod(_impl.state_product_left, None, state_product)
state_product.right = new_instancemethod(_impl.state_product_right, None, state_product)
state_product.clone = new_instancemethod(_impl.state_product_clone, None, state_product)
state_product_swigregister = _impl.state_product_swigregister
state_product_swigregister(state_product)

class twa_product(twa):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, left: 'spot::const_twa_ptr const &', right: 'spot::const_twa_ptr const &'):
        _impl.twa_product_swiginit(self, _impl.new_twa_product(left, right))
    __swig_destroy__ = _impl.delete_twa_product
twa_product.left_acc = new_instancemethod(_impl.twa_product_left_acc, None, twa_product)
twa_product.right_acc = new_instancemethod(_impl.twa_product_right_acc, None, twa_product)
twa_product_swigregister = _impl.twa_product_swigregister
twa_product_swigregister(twa_product)

class twa_product_init(twa_product):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, left: 'spot::const_twa_ptr const &', right: 'spot::const_twa_ptr const &', left_init: 'state', right_init: 'state'):
        _impl.twa_product_init_swiginit(self, _impl.new_twa_product_init(left, right, left_init, right_init))
    __swig_destroy__ = _impl.delete_twa_product_init
twa_product_init_swigregister = _impl.twa_product_init_swigregister
twa_product_init_swigregister(twa_product_init)


def otf_product(left: 'spot::const_twa_ptr const &', right: 'spot::const_twa_ptr const &') -> "spot::twa_product_ptr":
    return _impl.otf_product(left, right)
otf_product = _impl.otf_product

def otf_product_at(left: 'spot::const_twa_ptr const &', right: 'spot::const_twa_ptr const &', left_init: 'state', right_init: 'state') -> "spot::twa_product_ptr":
    return _impl.otf_product_at(left, right, left_init, right_init)
otf_product_at = _impl.otf_product_at
class const_universal_dests(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _impl.const_universal_dests_swiginit(self, _impl.new_const_universal_dests(*args))
    __swig_destroy__ = _impl.delete_const_universal_dests
const_universal_dests.begin = new_instancemethod(_impl.const_universal_dests_begin, None, const_universal_dests)
const_universal_dests.end = new_instancemethod(_impl.const_universal_dests_end, None, const_universal_dests)
const_universal_dests.__iter__ = new_instancemethod(_impl.const_universal_dests___iter__, None, const_universal_dests)
const_universal_dests_swigregister = _impl.const_universal_dests_swigregister
const_universal_dests_swigregister(const_universal_dests)

class twa_graph_state(state):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _impl.twa_graph_state_swiginit(self, _impl.new_twa_graph_state(*args))
    __swig_destroy__ = _impl.delete_twa_graph_state
twa_graph_state.clone = new_instancemethod(_impl.twa_graph_state_clone, None, twa_graph_state)
twa_graph_state_swigregister = _impl.twa_graph_state_swigregister
twa_graph_state_swigregister(twa_graph_state)

class twa_graph_edge_data(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    cond = _swig_property(_impl.twa_graph_edge_data_cond_get, _impl.twa_graph_edge_data_cond_set)
    acc = _swig_property(_impl.twa_graph_edge_data_acc_get, _impl.twa_graph_edge_data_acc_set)

    def __init__(self, *args):
        _impl.twa_graph_edge_data_swiginit(self, _impl.new_twa_graph_edge_data(*args))
    __swig_destroy__ = _impl.delete_twa_graph_edge_data
twa_graph_edge_data.__lt__ = new_instancemethod(_impl.twa_graph_edge_data___lt__, None, twa_graph_edge_data)
twa_graph_edge_data.__eq__ = new_instancemethod(_impl.twa_graph_edge_data___eq__, None, twa_graph_edge_data)
twa_graph_edge_data_swigregister = _impl.twa_graph_edge_data_swigregister
twa_graph_edge_data_swigregister(twa_graph_edge_data)

class twa_graph(twa):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _impl.twa_graph_swiginit(self, _impl.new_twa_graph(*args))
    __swig_destroy__ = _impl.delete_twa_graph
    is_univ_dest = staticmethod(_impl.twa_graph_is_univ_dest)

    def state_from_number(self, src: 'unsigned int') -> "spot::twa_graph_state const *":
        self.report_univ_dest(src)
        return _impl.twa_graph_state_from_number(self, src)



    def out(self, src: 'unsigned int'):
        self.report_univ_dest(src)
        return _impl.twa_graph_out(self, src)



    def state_acc_sets(self, src: 'unsigned int') -> "spot::acc_cond::mark_t":
        self.report_univ_dest(src)
        return _impl.twa_graph_state_acc_sets(self, src)



    def state_is_accepting(self, src) -> "bool":
        if type(src) == int:
            self.report_univ_dest(src)
        return _impl.twa_graph_state_is_accepting(self, src)


twa_graph.apply_permutation = new_instancemethod(_impl.twa_graph_apply_permutation, None, twa_graph)
twa_graph.get_graph = new_instancemethod(_impl.twa_graph_get_graph, None, twa_graph)
twa_graph.num_states = new_instancemethod(_impl.twa_graph_num_states, None, twa_graph)
twa_graph.num_edges = new_instancemethod(_impl.twa_graph_num_edges, None, twa_graph)
twa_graph.set_init_state = new_instancemethod(_impl.twa_graph_set_init_state, None, twa_graph)
twa_graph.get_init_state_number = new_instancemethod(_impl.twa_graph_get_init_state_number, None, twa_graph)
twa_graph.get_init_state = new_instancemethod(_impl.twa_graph_get_init_state, None, twa_graph)
twa_graph.state_number = new_instancemethod(_impl.twa_graph_state_number, None, twa_graph)
twa_graph.format_state = new_instancemethod(_impl.twa_graph_format_state, None, twa_graph)
twa_graph.edge_number = new_instancemethod(_impl.twa_graph_edge_number, None, twa_graph)
twa_graph.edge_data = new_instancemethod(_impl.twa_graph_edge_data, None, twa_graph)
twa_graph.edge_storage = new_instancemethod(_impl.twa_graph_edge_storage, None, twa_graph)
twa_graph.new_state = new_instancemethod(_impl.twa_graph_new_state, None, twa_graph)
twa_graph.new_states = new_instancemethod(_impl.twa_graph_new_states, None, twa_graph)
twa_graph.new_edge = new_instancemethod(_impl.twa_graph_new_edge, None, twa_graph)
twa_graph.new_acc_edge = new_instancemethod(_impl.twa_graph_new_acc_edge, None, twa_graph)
twa_graph.out_iteraser = new_instancemethod(_impl.twa_graph_out_iteraser, None, twa_graph)
twa_graph.univ_dests = new_instancemethod(_impl.twa_graph_univ_dests, None, twa_graph)
twa_graph.is_existential = new_instancemethod(_impl.twa_graph_is_existential, None, twa_graph)
twa_graph.edges = new_instancemethod(_impl.twa_graph_edges, None, twa_graph)
twa_graph.is_dead_edge = new_instancemethod(_impl.twa_graph_is_dead_edge, None, twa_graph)
twa_graph.merge_edges = new_instancemethod(_impl.twa_graph_merge_edges, None, twa_graph)
twa_graph.merge_univ_dests = new_instancemethod(_impl.twa_graph_merge_univ_dests, None, twa_graph)
twa_graph.merge_states = new_instancemethod(_impl.twa_graph_merge_states, None, twa_graph)
twa_graph.purge_dead_states = new_instancemethod(_impl.twa_graph_purge_dead_states, None, twa_graph)
twa_graph.purge_unreachable_states = new_instancemethod(_impl.twa_graph_purge_unreachable_states, None, twa_graph)
twa_graph.remove_unused_ap = new_instancemethod(_impl.twa_graph_remove_unused_ap, None, twa_graph)
twa_graph.copy_state_names_from = new_instancemethod(_impl.twa_graph_copy_state_names_from, None, twa_graph)
twa_graph.__eq__ = new_instancemethod(_impl.twa_graph___eq__, None, twa_graph)
twa_graph.defrag_states = new_instancemethod(_impl.twa_graph_defrag_states, None, twa_graph)
twa_graph.dump_storage_as_dot = new_instancemethod(_impl.twa_graph_dump_storage_as_dot, None, twa_graph)
twa_graph.new_univ_edge = new_instancemethod(_impl.twa_graph_new_univ_edge, None, twa_graph)
twa_graph.set_univ_init_state = new_instancemethod(_impl.twa_graph_set_univ_init_state, None, twa_graph)
twa_graph.report_univ_dest = new_instancemethod(_impl.twa_graph_report_univ_dest, None, twa_graph)
twa_graph_swigregister = _impl.twa_graph_swigregister
twa_graph_swigregister(twa_graph)

def twa_graph_is_univ_dest(*args) -> "bool":
    return _impl.twa_graph_is_univ_dest(*args)
twa_graph_is_univ_dest = _impl.twa_graph_is_univ_dest


def make_twa_graph(*args) -> "spot::twa_graph_ptr":
    return _impl.make_twa_graph(*args)
make_twa_graph = _impl.make_twa_graph
class twa_graph_state_out(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, g: 'spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > *', t: 'spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::edge'):
        _impl.twa_graph_state_out_swiginit(self, _impl.new_twa_graph_state_out(g, t))
    __swig_destroy__ = _impl.delete_twa_graph_state_out
twa_graph_state_out.begin = new_instancemethod(_impl.twa_graph_state_out_begin, None, twa_graph_state_out)
twa_graph_state_out.end = new_instancemethod(_impl.twa_graph_state_out_end, None, twa_graph_state_out)
twa_graph_state_out.recycle = new_instancemethod(_impl.twa_graph_state_out_recycle, None, twa_graph_state_out)
twa_graph_state_out.__iter__ = new_instancemethod(_impl.twa_graph_state_out___iter__, None, twa_graph_state_out)
twa_graph_state_out_swigregister = _impl.twa_graph_state_out_swigregister
twa_graph_state_out_swigregister(twa_graph_state_out)

class twa_graph_killer_edge_iterator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, g: 'spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > *', t: 'spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::edge', src: 'spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::state_storage_t &'):
        _impl.twa_graph_killer_edge_iterator_swiginit(self, _impl.new_twa_graph_killer_edge_iterator(g, t, src))
    __swig_destroy__ = _impl.delete_twa_graph_killer_edge_iterator
twa_graph_killer_edge_iterator.erase = new_instancemethod(_impl.twa_graph_killer_edge_iterator_erase, None, twa_graph_killer_edge_iterator)
twa_graph_killer_edge_iterator.current = new_instancemethod(_impl.twa_graph_killer_edge_iterator_current, None, twa_graph_killer_edge_iterator)
twa_graph_killer_edge_iterator.advance = new_instancemethod(_impl.twa_graph_killer_edge_iterator_advance, None, twa_graph_killer_edge_iterator)
twa_graph_killer_edge_iterator.__bool__ = new_instancemethod(_impl.twa_graph_killer_edge_iterator___bool__, None, twa_graph_killer_edge_iterator)
twa_graph_killer_edge_iterator_swigregister = _impl.twa_graph_killer_edge_iterator_swigregister
twa_graph_killer_edge_iterator_swigregister(twa_graph_killer_edge_iterator)

class twa_graph_all_trans(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, tv: 'spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::tv_t &'):
        _impl.twa_graph_all_trans_swiginit(self, _impl.new_twa_graph_all_trans(tv))
    __swig_destroy__ = _impl.delete_twa_graph_all_trans
twa_graph_all_trans.begin = new_instancemethod(_impl.twa_graph_all_trans_begin, None, twa_graph_all_trans)
twa_graph_all_trans.end = new_instancemethod(_impl.twa_graph_all_trans_end, None, twa_graph_all_trans)
twa_graph_all_trans.__iter__ = new_instancemethod(_impl.twa_graph_all_trans___iter__, None, twa_graph_all_trans)
twa_graph_all_trans_swigregister = _impl.twa_graph_all_trans_swigregister
twa_graph_all_trans_swigregister(twa_graph_all_trans)

class twa_graph_edge_boxed_data(twa_graph_edge_data):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _impl.twa_graph_edge_boxed_data_swiginit(self, _impl.new_twa_graph_edge_boxed_data())
    __swig_destroy__ = _impl.delete_twa_graph_edge_boxed_data
twa_graph_edge_boxed_data.data = new_instancemethod(_impl.twa_graph_edge_boxed_data_data, None, twa_graph_edge_boxed_data)
twa_graph_edge_boxed_data_swigregister = _impl.twa_graph_edge_boxed_data_swigregister
twa_graph_edge_boxed_data_swigregister(twa_graph_edge_boxed_data)

class twa_graph_edge_storage(twa_graph_edge_boxed_data):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    dst = _swig_property(_impl.twa_graph_edge_storage_dst_get, _impl.twa_graph_edge_storage_dst_set)
    next_succ = _swig_property(_impl.twa_graph_edge_storage_next_succ_get, _impl.twa_graph_edge_storage_next_succ_set)
    src = _swig_property(_impl.twa_graph_edge_storage_src_get, _impl.twa_graph_edge_storage_src_set)

    def __init__(self):
        _impl.twa_graph_edge_storage_swiginit(self, _impl.new_twa_graph_edge_storage())
    __swig_destroy__ = _impl.delete_twa_graph_edge_storage
twa_graph_edge_storage.__lt__ = new_instancemethod(_impl.twa_graph_edge_storage___lt__, None, twa_graph_edge_storage)
twa_graph_edge_storage.__eq__ = new_instancemethod(_impl.twa_graph_edge_storage___eq__, None, twa_graph_edge_storage)
twa_graph_edge_storage_swigregister = _impl.twa_graph_edge_storage_swigregister
twa_graph_edge_storage_swigregister(twa_graph_edge_storage)

class outedge_combiner(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, aut: 'spot::twa_graph_ptr const &'):
        _impl.outedge_combiner_swiginit(self, _impl.new_outedge_combiner(aut))
    __swig_destroy__ = _impl.delete_outedge_combiner
outedge_combiner.__call__ = new_instancemethod(_impl.outedge_combiner___call__, None, outedge_combiner)
outedge_combiner.new_dests = new_instancemethod(_impl.outedge_combiner_new_dests, None, outedge_combiner)
outedge_combiner_swigregister = _impl.outedge_combiner_swigregister
outedge_combiner_swigregister(outedge_combiner)


def remove_alternation(aut: 'spot::const_twa_graph_ptr const &', named_states: 'bool'=False, aborter: 'output_aborter const *'=None) -> "spot::twa_graph_ptr":
    return _impl.remove_alternation(aut, named_states, aborter)
remove_alternation = _impl.remove_alternation
class univ_remover_state(state):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _impl.univ_remover_state_swiginit(self, _impl.new_univ_remover_state(*args))
    __swig_destroy__ = _impl.delete_univ_remover_state
univ_remover_state.states = new_instancemethod(_impl.univ_remover_state_states, None, univ_remover_state)
univ_remover_state.is_reset = new_instancemethod(_impl.univ_remover_state_is_reset, None, univ_remover_state)
univ_remover_state_swigregister = _impl.univ_remover_state_swigregister
univ_remover_state_swigregister(univ_remover_state)

class twa_univ_remover(twa):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, aut: 'spot::const_twa_graph_ptr const &'):
        _impl.twa_univ_remover_swiginit(self, _impl.new_twa_univ_remover(aut))
    __swig_destroy__ = _impl.delete_twa_univ_remover
twa_univ_remover.allocate_state_vars = new_instancemethod(_impl.twa_univ_remover_allocate_state_vars, None, twa_univ_remover)
twa_univ_remover_swigregister = _impl.twa_univ_remover_swigregister
twa_univ_remover_swigregister(twa_univ_remover)


def remove_univ_otf(aut: 'spot::const_twa_graph_ptr const &') -> "spot::twa_univ_remover_ptr":
    return _impl.remove_univ_otf(aut)
remove_univ_otf = _impl.remove_univ_otf

def cleanup_acceptance_here(aut: 'spot::twa_graph_ptr', strip: 'bool'=True) -> "spot::twa_graph_ptr":
    return _impl.cleanup_acceptance_here(aut, strip)
cleanup_acceptance_here = _impl.cleanup_acceptance_here

def cleanup_acceptance(aut: 'spot::const_twa_graph_ptr', strip: 'bool'=True) -> "spot::twa_graph_ptr":
    return _impl.cleanup_acceptance(aut, strip)
cleanup_acceptance = _impl.cleanup_acceptance

def simplify_acceptance_here(aut: 'spot::twa_graph_ptr') -> "spot::twa_graph_ptr":
    return _impl.simplify_acceptance_here(aut)
simplify_acceptance_here = _impl.simplify_acceptance_here

def simplify_acceptance(aut: 'spot::const_twa_graph_ptr') -> "spot::twa_graph_ptr":
    return _impl.simplify_acceptance(aut)
simplify_acceptance = _impl.simplify_acceptance

def degeneralize(a: 'spot::const_twa_graph_ptr const &', use_z_lvl: 'bool'=True, use_cust_acc_orders: 'bool'=False, use_lvl_cache: 'int'=1, skip_levels: 'bool'=True, ignaccsl: 'bool'=False, remove_extra_scc: 'bool'=True) -> "spot::twa_graph_ptr":
    return _impl.degeneralize(a, use_z_lvl, use_cust_acc_orders, use_lvl_cache, skip_levels, ignaccsl, remove_extra_scc)
degeneralize = _impl.degeneralize

def degeneralize_tba(a: 'spot::const_twa_graph_ptr const &', use_z_lvl: 'bool'=True, use_cust_acc_orders: 'bool'=False, use_lvl_cache: 'int'=1, skip_levels: 'bool'=True, ignaccsl: 'bool'=False, remove_extra_scc: 'bool'=True) -> "spot::twa_graph_ptr":
    return _impl.degeneralize_tba(a, use_z_lvl, use_cust_acc_orders, use_lvl_cache, skip_levels, ignaccsl, remove_extra_scc)
degeneralize_tba = _impl.degeneralize_tba

def partial_degeneralize(*args) -> "spot::twa_graph_ptr":
    return _impl.partial_degeneralize(*args)
partial_degeneralize = _impl.partial_degeneralize

def is_partially_degeneralizable(*args) -> "spot::acc_cond::mark_t":
    return _impl.is_partially_degeneralizable(*args)
is_partially_degeneralizable = _impl.is_partially_degeneralizable

def propagate_marks_vector(aut: 'spot::const_twa_graph_ptr const &', si: 'scc_info'=None) -> "std::vector< spot::acc_cond::mark_t,std::allocator< spot::acc_cond::mark_t > >":
    return _impl.propagate_marks_vector(aut, si)
propagate_marks_vector = _impl.propagate_marks_vector

def propagate_marks_here(aut: 'spot::twa_graph_ptr &', si: 'scc_info'=None) -> "void":
    return _impl.propagate_marks_here(aut, si)
propagate_marks_here = _impl.propagate_marks_here
class nca_st_info(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    clause_num = _swig_property(_impl.nca_st_info_clause_num_get, _impl.nca_st_info_clause_num_set)
    state_num = _swig_property(_impl.nca_st_info_state_num_get, _impl.nca_st_info_state_num_set)
    all_dst = _swig_property(_impl.nca_st_info_all_dst_get, _impl.nca_st_info_all_dst_set)

    def __init__(self, clause: 'unsigned int', st: 'unsigned int', dst: 'bitvect *'):
        _impl.nca_st_info_swiginit(self, _impl.new_nca_st_info(clause, st, dst))
    __swig_destroy__ = _impl.delete_nca_st_info
nca_st_info_swigregister = _impl.nca_st_info_swigregister
nca_st_info_swigregister(nca_st_info)


def nsa_to_nca(aut: 'spot::const_twa_graph_ptr', named_states: 'bool'=False, nca_info: 'spot::vect_nca_info *'=None) -> "spot::twa_graph_ptr":
    return _impl.nsa_to_nca(aut, named_states, nca_info)
nsa_to_nca = _impl.nsa_to_nca

def dnf_to_nca(aut: 'spot::const_twa_graph_ptr', named_states: 'bool'=False, nca_info: 'spot::vect_nca_info *'=None) -> "spot::twa_graph_ptr":
    return _impl.dnf_to_nca(aut, named_states, nca_info)
dnf_to_nca = _impl.dnf_to_nca

def to_nca(aut: 'spot::const_twa_graph_ptr', named_states: 'bool'=False) -> "spot::twa_graph_ptr":
    return _impl.to_nca(aut, named_states)
to_nca = _impl.to_nca

def nsa_to_dca(aut: 'spot::const_twa_graph_ptr', named_states: 'bool'=False) -> "spot::twa_graph_ptr":
    return _impl.nsa_to_dca(aut, named_states)
nsa_to_dca = _impl.nsa_to_dca

def dnf_to_dca(aut: 'spot::const_twa_graph_ptr', named_states: 'bool'=False) -> "spot::twa_graph_ptr":
    return _impl.dnf_to_dca(aut, named_states)
dnf_to_dca = _impl.dnf_to_dca

def to_dca(aut: 'spot::const_twa_graph_ptr', named_states: 'bool'=False) -> "spot::twa_graph_ptr":
    return _impl.to_dca(aut, named_states)
to_dca = _impl.to_dca

def copy(aut: 'spot::const_twa_ptr const &', p: 'spot::twa::prop_set', preserve_names: 'bool'=False, max_states: 'unsigned int'=-1) -> "spot::twa_graph_ptr":
    return _impl.copy(aut, p, preserve_names, max_states)
copy = _impl.copy

def complete_here(aut: 'spot::twa_graph_ptr') -> "void":
    return _impl.complete_here(aut)
complete_here = _impl.complete_here

def complete(aut: 'spot::const_twa_ptr const &') -> "spot::twa_graph_ptr":
    return _impl.complete(aut)
complete = _impl.complete
class emptiness_check_result(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _impl.emptiness_check_result_swiginit(self, _impl.new_emptiness_check_result(*args))
    __swig_destroy__ = _impl.delete_emptiness_check_result
emptiness_check_result.accepting_run = new_instancemethod(_impl.emptiness_check_result_accepting_run, None, emptiness_check_result)
emptiness_check_result.automaton = new_instancemethod(_impl.emptiness_check_result_automaton, None, emptiness_check_result)
emptiness_check_result.options = new_instancemethod(_impl.emptiness_check_result_options, None, emptiness_check_result)
emptiness_check_result.parse_options = new_instancemethod(_impl.emptiness_check_result_parse_options, None, emptiness_check_result)
emptiness_check_result.statistics = new_instancemethod(_impl.emptiness_check_result_statistics, None, emptiness_check_result)
emptiness_check_result_swigregister = _impl.emptiness_check_result_swigregister
emptiness_check_result_swigregister(emptiness_check_result)

class emptiness_check(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _impl.delete_emptiness_check
emptiness_check.automaton = new_instancemethod(_impl.emptiness_check_automaton, None, emptiness_check)
emptiness_check.options = new_instancemethod(_impl.emptiness_check_options, None, emptiness_check)
emptiness_check.parse_options = new_instancemethod(_impl.emptiness_check_parse_options, None, emptiness_check)
emptiness_check.safe = new_instancemethod(_impl.emptiness_check_safe, None, emptiness_check)
emptiness_check.check = new_instancemethod(_impl.emptiness_check_check, None, emptiness_check)
emptiness_check.statistics = new_instancemethod(_impl.emptiness_check_statistics, None, emptiness_check)
emptiness_check.emptiness_check_statistics = new_instancemethod(_impl.emptiness_check_emptiness_check_statistics, None, emptiness_check)
emptiness_check.print_stats = new_instancemethod(_impl.emptiness_check_print_stats, None, emptiness_check)
emptiness_check.options_updated = new_instancemethod(_impl.emptiness_check_options_updated, None, emptiness_check)
emptiness_check_swigregister = _impl.emptiness_check_swigregister
emptiness_check_swigregister(emptiness_check)

class emptiness_check_instantiator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _impl.delete_emptiness_check_instantiator
emptiness_check_instantiator.instantiate = new_instancemethod(_impl.emptiness_check_instantiator_instantiate, None, emptiness_check_instantiator)
emptiness_check_instantiator.options = new_instancemethod(_impl.emptiness_check_instantiator_options, None, emptiness_check_instantiator)
emptiness_check_instantiator.min_sets = new_instancemethod(_impl.emptiness_check_instantiator_min_sets, None, emptiness_check_instantiator)
emptiness_check_instantiator.max_sets = new_instancemethod(_impl.emptiness_check_instantiator_max_sets, None, emptiness_check_instantiator)
emptiness_check_instantiator_swigregister = _impl.emptiness_check_instantiator_swigregister
emptiness_check_instantiator_swigregister(emptiness_check_instantiator)


def make_emptiness_check_instantiator(name: 'char const *') -> "char **":
    return _impl.make_emptiness_check_instantiator(name)
make_emptiness_check_instantiator = _impl.make_emptiness_check_instantiator
class twa_run(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    prefix = _swig_property(_impl.twa_run_prefix_get, _impl.twa_run_prefix_set)
    cycle = _swig_property(_impl.twa_run_cycle_get, _impl.twa_run_cycle_set)
    aut = _swig_property(_impl.twa_run_aut_get, _impl.twa_run_aut_set)
    __swig_destroy__ = _impl.delete_twa_run

    def __init__(self, *args):
        _impl.twa_run_swiginit(self, _impl.new_twa_run(*args))
twa_run.ensure_non_empty_cycle = new_instancemethod(_impl.twa_run_ensure_non_empty_cycle, None, twa_run)
twa_run.reduce = new_instancemethod(_impl.twa_run_reduce, None, twa_run)
twa_run.project = new_instancemethod(_impl.twa_run_project, None, twa_run)
twa_run.replay = new_instancemethod(_impl.twa_run_replay, None, twa_run)
twa_run.highlight = new_instancemethod(_impl.twa_run_highlight, None, twa_run)
twa_run.as_twa = new_instancemethod(_impl.twa_run_as_twa, None, twa_run)
twa_run.__str__ = new_instancemethod(_impl.twa_run___str__, None, twa_run)
twa_run_swigregister = _impl.twa_run_swigregister
twa_run_swigregister(twa_run)

class step(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    s = _swig_property(_impl.step_s_get, _impl.step_s_set)
    label = _swig_property(_impl.step_label_get, _impl.step_label_set)
    acc = _swig_property(_impl.step_acc_get, _impl.step_acc_set)

    def __init__(self, *args):
        _impl.step_swiginit(self, _impl.new_step(*args))
    __swig_destroy__ = _impl.delete_step
step_swigregister = _impl.step_swigregister
step_swigregister(step)

class list_step(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __iter__(self):
        return self.iterator()

    def __init__(self, *args):
        _impl.list_step_swiginit(self, _impl.new_list_step(*args))
    __swig_destroy__ = _impl.delete_list_step
list_step.iterator = new_instancemethod(_impl.list_step_iterator, None, list_step)
list_step.__nonzero__ = new_instancemethod(_impl.list_step___nonzero__, None, list_step)
list_step.__bool__ = new_instancemethod(_impl.list_step___bool__, None, list_step)
list_step.__len__ = new_instancemethod(_impl.list_step___len__, None, list_step)
list_step.__getslice__ = new_instancemethod(_impl.list_step___getslice__, None, list_step)
list_step.__setslice__ = new_instancemethod(_impl.list_step___setslice__, None, list_step)
list_step.__delslice__ = new_instancemethod(_impl.list_step___delslice__, None, list_step)
list_step.__delitem__ = new_instancemethod(_impl.list_step___delitem__, None, list_step)
list_step.__getitem__ = new_instancemethod(_impl.list_step___getitem__, None, list_step)
list_step.__setitem__ = new_instancemethod(_impl.list_step___setitem__, None, list_step)
list_step.pop = new_instancemethod(_impl.list_step_pop, None, list_step)
list_step.append = new_instancemethod(_impl.list_step_append, None, list_step)
list_step.empty = new_instancemethod(_impl.list_step_empty, None, list_step)
list_step.size = new_instancemethod(_impl.list_step_size, None, list_step)
list_step.swap = new_instancemethod(_impl.list_step_swap, None, list_step)
list_step.begin = new_instancemethod(_impl.list_step_begin, None, list_step)
list_step.end = new_instancemethod(_impl.list_step_end, None, list_step)
list_step.rbegin = new_instancemethod(_impl.list_step_rbegin, None, list_step)
list_step.rend = new_instancemethod(_impl.list_step_rend, None, list_step)
list_step.clear = new_instancemethod(_impl.list_step_clear, None, list_step)
list_step.get_allocator = new_instancemethod(_impl.list_step_get_allocator, None, list_step)
list_step.pop_back = new_instancemethod(_impl.list_step_pop_back, None, list_step)
list_step.erase = new_instancemethod(_impl.list_step_erase, None, list_step)
list_step.push_back = new_instancemethod(_impl.list_step_push_back, None, list_step)
list_step.front = new_instancemethod(_impl.list_step_front, None, list_step)
list_step.back = new_instancemethod(_impl.list_step_back, None, list_step)
list_step.assign = new_instancemethod(_impl.list_step_assign, None, list_step)
list_step.resize = new_instancemethod(_impl.list_step_resize, None, list_step)
list_step.insert = new_instancemethod(_impl.list_step_insert, None, list_step)
list_step.pop_front = new_instancemethod(_impl.list_step_pop_front, None, list_step)
list_step.push_front = new_instancemethod(_impl.list_step_push_front, None, list_step)
list_step.reverse = new_instancemethod(_impl.list_step_reverse, None, list_step)
list_step_swigregister = _impl.list_step_swigregister
list_step_swigregister(list_step)


def couvreur99(*args) -> "spot::emptiness_check_ptr":
    return _impl.couvreur99(*args)
couvreur99 = _impl.couvreur99

def generic_emptiness_check(aut: 'spot::const_twa_graph_ptr const &') -> "bool":
    return _impl.generic_emptiness_check(aut)
generic_emptiness_check = _impl.generic_emptiness_check

def generic_accepting_run(aut: 'spot::const_twa_graph_ptr const &') -> "spot::twa_run_ptr":
    return _impl.generic_accepting_run(aut)
generic_accepting_run = _impl.generic_accepting_run

def generic_emptiness_check_for_scc(*args) -> "bool":
    return _impl.generic_emptiness_check_for_scc(*args)
generic_emptiness_check_for_scc = _impl.generic_emptiness_check_for_scc

def generic_emptiness_check_select_version(emversion: 'char const *'=None) -> "void":
    return _impl.generic_emptiness_check_select_version(emversion)
generic_emptiness_check_select_version = _impl.generic_emptiness_check_select_version

def print_lbtt(os: 'ostream', g: 'spot::const_twa_ptr const &', opt: 'char const *'=None) -> "std::ostream &":
    return _impl.print_lbtt(os, g, opt)
print_lbtt = _impl.print_lbtt

def ltl_to_taa(f: 'formula', dict: 'spot::bdd_dict_ptr const &', refined_rules: 'bool'=False) -> "spot::taa_tgba_formula_ptr":
    return _impl.ltl_to_taa(f, dict, refined_rules)
ltl_to_taa = _impl.ltl_to_taa

def ltl_to_tgba_fm(f: 'formula', dict: 'spot::bdd_dict_ptr const &', exprop: 'bool'=False, symb_merge: 'bool'=True, branching_postponement: 'bool'=False, fair_loop_approx: 'bool'=False, unobs: 'atomic_prop_set'=None, simplifier: 'tl_simplifier'=None, unambiguous: 'bool'=False) -> "spot::twa_graph_ptr":
    return _impl.ltl_to_tgba_fm(f, dict, exprop, symb_merge, branching_postponement, fair_loop_approx, unobs, simplifier, unambiguous)
ltl_to_tgba_fm = _impl.ltl_to_tgba_fm

def g_f_terminal_inplace(f_terminal: 'spot::twa_graph_ptr', state_based: 'bool'=False) -> "spot::twa_graph_ptr":
    return _impl.g_f_terminal_inplace(f_terminal, state_based)
g_f_terminal_inplace = _impl.g_f_terminal_inplace

def gf_guarantee_to_ba_maybe(gf: 'formula', dict: 'spot::bdd_dict_ptr const &', deterministic: 'bool'=True, state_based: 'bool'=False) -> "spot::twa_graph_ptr":
    return _impl.gf_guarantee_to_ba_maybe(gf, dict, deterministic, state_based)
gf_guarantee_to_ba_maybe = _impl.gf_guarantee_to_ba_maybe

def gf_guarantee_to_ba(gf: 'formula', dict: 'spot::bdd_dict_ptr const &', deterministic: 'bool'=True, state_based: 'bool'=False) -> "spot::twa_graph_ptr":
    return _impl.gf_guarantee_to_ba(gf, dict, deterministic, state_based)
gf_guarantee_to_ba = _impl.gf_guarantee_to_ba

def fg_safety_to_dca_maybe(fg: 'formula', dict: 'spot::bdd_dict_ptr const &', state_based: 'bool') -> "spot::twa_graph_ptr":
    return _impl.fg_safety_to_dca_maybe(fg, dict, state_based)
fg_safety_to_dca_maybe = _impl.fg_safety_to_dca_maybe

def fg_safety_to_dca(fg: 'formula', dict: 'spot::bdd_dict_ptr const &', state_based: 'bool'=False) -> "spot::twa_graph_ptr":
    return _impl.fg_safety_to_dca(fg, dict, state_based)
fg_safety_to_dca = _impl.fg_safety_to_dca

def compsusp(f: 'formula', dict: 'spot::bdd_dict_ptr const &', no_wdba: 'bool'=False, no_simulation: 'bool'=False, early_susp: 'bool'=False, no_susp_product: 'bool'=False, wdba_smaller: 'bool'=False, oblig: 'bool'=False) -> "spot::twa_graph_ptr":
    return _impl.compsusp(f, dict, no_wdba, no_simulation, early_susp, no_susp_product, wdba_smaller, oblig)
compsusp = _impl.compsusp

def contains(*args) -> "bool":
    return _impl.contains(*args)
contains = _impl.contains

def are_equivalent(*args) -> "bool":
    return _impl.are_equivalent(*args)
are_equivalent = _impl.are_equivalent

def tgba_determinize(aut: 'spot::const_twa_graph_ptr const &', pretty_print: 'bool'=False, use_scc: 'bool'=True, use_simulation: 'bool'=True, use_stutter: 'bool'=True, aborter: 'output_aborter const *'=None) -> "spot::twa_graph_ptr":
    return _impl.tgba_determinize(aut, pretty_print, use_scc, use_simulation, use_stutter, aborter)
tgba_determinize = _impl.tgba_determinize

def dualize(aut: 'spot::const_twa_graph_ptr const &') -> "spot::twa_graph_ptr":
    return _impl.dualize(aut)
dualize = _impl.dualize

def language_map(aut: 'spot::const_twa_graph_ptr const &') -> "std::vector< unsigned int,std::allocator< unsigned int > >":
    return _impl.language_map(aut)
language_map = _impl.language_map

def highlight_languages(aut: 'spot::twa_graph_ptr &') -> "void":
    return _impl.highlight_languages(aut)
highlight_languages = _impl.highlight_languages

def explicit_magic_search(*args) -> "spot::emptiness_check_ptr":
    return _impl.explicit_magic_search(*args)
explicit_magic_search = _impl.explicit_magic_search

def bit_state_hashing_magic_search(*args) -> "spot::emptiness_check_ptr":
    return _impl.bit_state_hashing_magic_search(*args)
bit_state_hashing_magic_search = _impl.bit_state_hashing_magic_search

def magic_search(*args) -> "spot::emptiness_check_ptr":
    return _impl.magic_search(*args)
magic_search = _impl.magic_search

def minimize_monitor(a: 'spot::const_twa_graph_ptr const &') -> "spot::twa_graph_ptr":
    return _impl.minimize_monitor(a)
minimize_monitor = _impl.minimize_monitor

def minimize_wdba(a: 'spot::const_twa_graph_ptr const &', aborter: 'output_aborter const *'=None) -> "spot::twa_graph_ptr":
    return _impl.minimize_wdba(a, aborter)
minimize_wdba = _impl.minimize_wdba

def minimize_obligation(aut_f: 'spot::const_twa_graph_ptr const &', f: 'formula'=0, aut_neg_f: 'spot::const_twa_graph_ptr'=0, reject_bigger: 'bool'=False, aborter: 'output_aborter const *'=None) -> "spot::twa_graph_ptr":
    return _impl.minimize_obligation(aut_f, f, aut_neg_f, reject_bigger, aborter)
minimize_obligation = _impl.minimize_obligation

def minimize_obligation_garanteed_to_work(aut_f: 'spot::const_twa_graph_ptr const &', f: 'formula'=0) -> "bool":
    return _impl.minimize_obligation_garanteed_to_work(aut_f, f)
minimize_obligation_garanteed_to_work = _impl.minimize_obligation_garanteed_to_work

def print_never_claim(os: 'ostream', g: 'spot::const_twa_ptr const &', opt: 'char const *'=None) -> "std::ostream &":
    return _impl.print_never_claim(os, g, opt)
print_never_claim = _impl.print_never_claim

def randomize(aut: 'spot::twa_graph_ptr &', randomize_states: 'bool'=True, randomize_edges: 'bool'=True) -> "void":
    return _impl.randomize(aut, randomize_states, randomize_edges)
randomize = _impl.randomize

def rabin_is_buchi_realizable(aut: 'spot::const_twa_graph_ptr const &') -> "bool":
    return _impl.rabin_is_buchi_realizable(aut)
rabin_is_buchi_realizable = _impl.rabin_is_buchi_realizable

def rabin_to_buchi_if_realizable(aut: 'spot::const_twa_graph_ptr const &') -> "spot::twa_graph_ptr":
    return _impl.rabin_to_buchi_if_realizable(aut)
rabin_to_buchi_if_realizable = _impl.rabin_to_buchi_if_realizable

def rabin_to_buchi_maybe(aut: 'spot::const_twa_graph_ptr const &') -> "spot::twa_graph_ptr":
    return _impl.rabin_to_buchi_maybe(aut)
rabin_to_buchi_maybe = _impl.rabin_to_buchi_maybe

def remove_fin(aut: 'spot::const_twa_graph_ptr const &') -> "spot::twa_graph_ptr":
    return _impl.remove_fin(aut)
remove_fin = _impl.remove_fin
class remove_ap(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _impl.remove_ap_swiginit(self, _impl.new_remove_ap())
    __swig_destroy__ = _impl.delete_remove_ap
remove_ap.add_ap = new_instancemethod(_impl.remove_ap_add_ap, None, remove_ap)
remove_ap.empty = new_instancemethod(_impl.remove_ap_empty, None, remove_ap)
remove_ap.strip = new_instancemethod(_impl.remove_ap_strip, None, remove_ap)
remove_ap_swigregister = _impl.remove_ap_swigregister
remove_ap_swigregister(remove_ap)


def to_generalized_buchi(aut: 'spot::const_twa_graph_ptr const &') -> "spot::twa_graph_ptr":
    return _impl.to_generalized_buchi(aut)
to_generalized_buchi = _impl.to_generalized_buchi

def streett_to_generalized_buchi(arg1: 'spot::const_twa_graph_ptr const &') -> "spot::twa_graph_ptr":
    return _impl.streett_to_generalized_buchi(arg1)
streett_to_generalized_buchi = _impl.streett_to_generalized_buchi

def streett_to_generalized_buchi_maybe(arg1: 'spot::const_twa_graph_ptr const &') -> "spot::twa_graph_ptr":
    return _impl.streett_to_generalized_buchi_maybe(arg1)
streett_to_generalized_buchi_maybe = _impl.streett_to_generalized_buchi_maybe

def to_generalized_rabin(aut: 'spot::const_twa_graph_ptr const &', share_inf: 'bool'=False) -> "spot::twa_graph_ptr":
    return _impl.to_generalized_rabin(aut, share_inf)
to_generalized_rabin = _impl.to_generalized_rabin

def to_generalized_streett(aut: 'spot::const_twa_graph_ptr const &', share_fin: 'bool'=False) -> "spot::twa_graph_ptr":
    return _impl.to_generalized_streett(aut, share_fin)
to_generalized_streett = _impl.to_generalized_streett

def dnf_to_streett(aut: 'spot::const_twa_graph_ptr const &', original_states: 'bool'=False) -> "spot::twa_graph_ptr":
    return _impl.dnf_to_streett(aut, original_states)
dnf_to_streett = _impl.dnf_to_streett

def sbacc(aut: 'spot::twa_graph_ptr') -> "spot::twa_graph_ptr":
    return _impl.sbacc(aut)
sbacc = _impl.sbacc
edge_filter_choice_keep = _impl.edge_filter_choice_keep
edge_filter_choice_ignore = _impl.edge_filter_choice_ignore
edge_filter_choice_cut = _impl.edge_filter_choice_cut
class keep_all(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _impl.keep_all_swiginit(self, _impl.new_keep_all())
    __swig_destroy__ = _impl.delete_keep_all
keep_all_swigregister = _impl.keep_all_swigregister
keep_all_swigregister(keep_all)

class keep_inner_scc(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, sccof: 'vectorunsigned', desired_scc: 'unsigned int'):
        _impl.keep_inner_scc_swiginit(self, _impl.new_keep_inner_scc(sccof, desired_scc))
    __swig_destroy__ = _impl.delete_keep_inner_scc
keep_inner_scc_swigregister = _impl.keep_inner_scc_swigregister
keep_inner_scc_swigregister(keep_inner_scc)

class scc_info_node(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _impl.scc_info_node_swiginit(self, _impl.new_scc_info_node(*args))
    __swig_destroy__ = _impl.delete_scc_info_node
scc_info_node.is_trivial = new_instancemethod(_impl.scc_info_node_is_trivial, None, scc_info_node)
scc_info_node.is_accepting = new_instancemethod(_impl.scc_info_node_is_accepting, None, scc_info_node)
scc_info_node.is_rejecting = new_instancemethod(_impl.scc_info_node_is_rejecting, None, scc_info_node)
scc_info_node.is_useful = new_instancemethod(_impl.scc_info_node_is_useful, None, scc_info_node)
scc_info_node.acc_marks = new_instancemethod(_impl.scc_info_node_acc_marks, None, scc_info_node)
scc_info_node.common_marks = new_instancemethod(_impl.scc_info_node_common_marks, None, scc_info_node)
scc_info_node.states = new_instancemethod(_impl.scc_info_node_states, None, scc_info_node)
scc_info_node.one_state = new_instancemethod(_impl.scc_info_node_one_state, None, scc_info_node)
scc_info_node.succ = new_instancemethod(_impl.scc_info_node_succ, None, scc_info_node)
scc_info_node_swigregister = _impl.scc_info_node_swigregister
scc_info_node_swigregister(scc_info_node)

scc_info_options_NONE = _impl.scc_info_options_NONE
scc_info_options_STOP_ON_ACC = _impl.scc_info_options_STOP_ON_ACC
scc_info_options_TRACK_STATES = _impl.scc_info_options_TRACK_STATES
scc_info_options_TRACK_SUCCS = _impl.scc_info_options_TRACK_SUCCS
scc_info_options_TRACK_STATES_IF_FIN_USED = _impl.scc_info_options_TRACK_STATES_IF_FIN_USED
scc_info_options_ALL = _impl.scc_info_options_ALL

def __and__(left: 'spot::scc_info_options', right: 'spot::scc_info_options') -> "spot::scc_info_options":
    return _impl.__and__(left, right)
__and__ = _impl.__and__

def __or__(left: 'spot::scc_info_options', right: 'spot::scc_info_options') -> "spot::scc_info_options":
    return _impl.__or__(left, right)
__or__ = _impl.__or__
class scc_info(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _impl.scc_info_swiginit(self, _impl.new_scc_info(*args))
    __swig_destroy__ = _impl.delete_scc_info
scc_info.get_aut = new_instancemethod(_impl.scc_info_get_aut, None, scc_info)
scc_info.get_options = new_instancemethod(_impl.scc_info_get_options, None, scc_info)
scc_info.get_filter = new_instancemethod(_impl.scc_info_get_filter, None, scc_info)
scc_info.get_filter_data = new_instancemethod(_impl.scc_info_get_filter_data, None, scc_info)
scc_info.scc_count = new_instancemethod(_impl.scc_info_scc_count, None, scc_info)
scc_info.one_accepting_scc = new_instancemethod(_impl.scc_info_one_accepting_scc, None, scc_info)
scc_info.reachable_state = new_instancemethod(_impl.scc_info_reachable_state, None, scc_info)
scc_info.scc_of = new_instancemethod(_impl.scc_info_scc_of, None, scc_info)
scc_info.begin = new_instancemethod(_impl.scc_info_begin, None, scc_info)
scc_info.end = new_instancemethod(_impl.scc_info_end, None, scc_info)
scc_info.cbegin = new_instancemethod(_impl.scc_info_cbegin, None, scc_info)
scc_info.cend = new_instancemethod(_impl.scc_info_cend, None, scc_info)
scc_info.rbegin = new_instancemethod(_impl.scc_info_rbegin, None, scc_info)
scc_info.rend = new_instancemethod(_impl.scc_info_rend, None, scc_info)
scc_info.states_of = new_instancemethod(_impl.scc_info_states_of, None, scc_info)
scc_info.edges_of = new_instancemethod(_impl.scc_info_edges_of, None, scc_info)
scc_info.inner_edges_of = new_instancemethod(_impl.scc_info_inner_edges_of, None, scc_info)
scc_info.one_state_of = new_instancemethod(_impl.scc_info_one_state_of, None, scc_info)
scc_info.initial = new_instancemethod(_impl.scc_info_initial, None, scc_info)
scc_info.succ = new_instancemethod(_impl.scc_info_succ, None, scc_info)
scc_info.is_trivial = new_instancemethod(_impl.scc_info_is_trivial, None, scc_info)
scc_info.acc = new_instancemethod(_impl.scc_info_acc, None, scc_info)
scc_info.is_accepting_scc = new_instancemethod(_impl.scc_info_is_accepting_scc, None, scc_info)
scc_info.is_rejecting_scc = new_instancemethod(_impl.scc_info_is_rejecting_scc, None, scc_info)
scc_info.determine_unknown_acceptance = new_instancemethod(_impl.scc_info_determine_unknown_acceptance, None, scc_info)
scc_info.check_scc_emptiness = new_instancemethod(_impl.scc_info_check_scc_emptiness, None, scc_info)
scc_info.get_accepting_run = new_instancemethod(_impl.scc_info_get_accepting_run, None, scc_info)
scc_info.is_useful_scc = new_instancemethod(_impl.scc_info_is_useful_scc, None, scc_info)
scc_info.is_useful_state = new_instancemethod(_impl.scc_info_is_useful_state, None, scc_info)
scc_info.marks = new_instancemethod(_impl.scc_info_marks, None, scc_info)
scc_info.marks_of = new_instancemethod(_impl.scc_info_marks_of, None, scc_info)
scc_info.used_acc = new_instancemethod(_impl.scc_info_used_acc, None, scc_info)
scc_info.used_acc_of = new_instancemethod(_impl.scc_info_used_acc_of, None, scc_info)
scc_info.acc_sets_of = new_instancemethod(_impl.scc_info_acc_sets_of, None, scc_info)
scc_info.common_sets_of = new_instancemethod(_impl.scc_info_common_sets_of, None, scc_info)
scc_info.weak_sccs = new_instancemethod(_impl.scc_info_weak_sccs, None, scc_info)
scc_info.scc_ap_support = new_instancemethod(_impl.scc_info_scc_ap_support, None, scc_info)
scc_info.split_on_sets = new_instancemethod(_impl.scc_info_split_on_sets, None, scc_info)
scc_info.states_on_acc_cycle_of = new_instancemethod(_impl.scc_info_states_on_acc_cycle_of, None, scc_info)
scc_info.__iter__ = new_instancemethod(_impl.scc_info___iter__, None, scc_info)
scc_info_swigregister = _impl.scc_info_swigregister
scc_info_swigregister(scc_info)

def scc_info_with_options(*args):
    val = _impl.new_scc_info_with_options(*args)
    return val

class scc_and_mark_filter(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _impl.scc_and_mark_filter_swiginit(self, _impl.new_scc_and_mark_filter(*args))
    __swig_destroy__ = _impl.delete_scc_and_mark_filter
scc_and_mark_filter.override_acceptance = new_instancemethod(_impl.scc_and_mark_filter_override_acceptance, None, scc_and_mark_filter)
scc_and_mark_filter.restore_acceptance = new_instancemethod(_impl.scc_and_mark_filter_restore_acceptance, None, scc_and_mark_filter)
scc_and_mark_filter.get_aut = new_instancemethod(_impl.scc_and_mark_filter_get_aut, None, scc_and_mark_filter)
scc_and_mark_filter.start_state = new_instancemethod(_impl.scc_and_mark_filter_start_state, None, scc_and_mark_filter)
scc_and_mark_filter.get_filter = new_instancemethod(_impl.scc_and_mark_filter_get_filter, None, scc_and_mark_filter)
scc_and_mark_filter_swigregister = _impl.scc_and_mark_filter_swigregister
scc_and_mark_filter_swigregister(scc_and_mark_filter)


def dump_scc_info_dot(out: 'ostream', aut: 'spot::const_twa_graph_ptr', sccinfo: 'scc_info'=None) -> "std::ostream &":
    return _impl.dump_scc_info_dot(out, aut, sccinfo)
dump_scc_info_dot = _impl.dump_scc_info_dot
class scc_info_scc_edges(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, begin: 'spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::state_iterator', end: 'spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::state_iterator', tv: 'spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::tv_t *', sv: 'spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::sv_t *', dv: 'spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::dv_t *', filt: 'keep_all', efilter: 'spot::edge_filter', efilter_data: 'void *'):
        _impl.scc_info_scc_edges_swiginit(self, _impl.new_scc_info_scc_edges(begin, end, tv, sv, dv, filt, efilter, efilter_data))
    __swig_destroy__ = _impl.delete_scc_info_scc_edges
scc_info_scc_edges.begin = new_instancemethod(_impl.scc_info_scc_edges_begin, None, scc_info_scc_edges)
scc_info_scc_edges.end = new_instancemethod(_impl.scc_info_scc_edges_end, None, scc_info_scc_edges)
scc_info_scc_edges.__iter__ = new_instancemethod(_impl.scc_info_scc_edges___iter__, None, scc_info_scc_edges)
scc_info_scc_edges_swigregister = _impl.scc_info_scc_edges_swigregister
scc_info_scc_edges_swigregister(scc_info_scc_edges)

class scc_info_inner_scc_edges(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, begin: 'spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::state_iterator', end: 'spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::state_iterator', tv: 'spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::tv_t *', sv: 'spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::sv_t *', dv: 'spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::dv_t *', filt: 'keep_inner_scc', efilter: 'spot::edge_filter', efilter_data: 'void *'):
        _impl.scc_info_inner_scc_edges_swiginit(self, _impl.new_scc_info_inner_scc_edges(begin, end, tv, sv, dv, filt, efilter, efilter_data))
    __swig_destroy__ = _impl.delete_scc_info_inner_scc_edges
scc_info_inner_scc_edges.begin = new_instancemethod(_impl.scc_info_inner_scc_edges_begin, None, scc_info_inner_scc_edges)
scc_info_inner_scc_edges.end = new_instancemethod(_impl.scc_info_inner_scc_edges_end, None, scc_info_inner_scc_edges)
scc_info_inner_scc_edges.__iter__ = new_instancemethod(_impl.scc_info_inner_scc_edges___iter__, None, scc_info_inner_scc_edges)
scc_info_inner_scc_edges_swigregister = _impl.scc_info_inner_scc_edges_swigregister
scc_info_inner_scc_edges_swigregister(scc_info_inner_scc_edges)

class vector_twa_graph(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __iter__(self):
        return self.iterator()

    def __init__(self, *args):
        _impl.vector_twa_graph_swiginit(self, _impl.new_vector_twa_graph(*args))
    __swig_destroy__ = _impl.delete_vector_twa_graph
vector_twa_graph.iterator = new_instancemethod(_impl.vector_twa_graph_iterator, None, vector_twa_graph)
vector_twa_graph.__nonzero__ = new_instancemethod(_impl.vector_twa_graph___nonzero__, None, vector_twa_graph)
vector_twa_graph.__bool__ = new_instancemethod(_impl.vector_twa_graph___bool__, None, vector_twa_graph)
vector_twa_graph.__len__ = new_instancemethod(_impl.vector_twa_graph___len__, None, vector_twa_graph)
vector_twa_graph.__getslice__ = new_instancemethod(_impl.vector_twa_graph___getslice__, None, vector_twa_graph)
vector_twa_graph.__setslice__ = new_instancemethod(_impl.vector_twa_graph___setslice__, None, vector_twa_graph)
vector_twa_graph.__delslice__ = new_instancemethod(_impl.vector_twa_graph___delslice__, None, vector_twa_graph)
vector_twa_graph.__delitem__ = new_instancemethod(_impl.vector_twa_graph___delitem__, None, vector_twa_graph)
vector_twa_graph.__getitem__ = new_instancemethod(_impl.vector_twa_graph___getitem__, None, vector_twa_graph)
vector_twa_graph.__setitem__ = new_instancemethod(_impl.vector_twa_graph___setitem__, None, vector_twa_graph)
vector_twa_graph.pop = new_instancemethod(_impl.vector_twa_graph_pop, None, vector_twa_graph)
vector_twa_graph.append = new_instancemethod(_impl.vector_twa_graph_append, None, vector_twa_graph)
vector_twa_graph.empty = new_instancemethod(_impl.vector_twa_graph_empty, None, vector_twa_graph)
vector_twa_graph.size = new_instancemethod(_impl.vector_twa_graph_size, None, vector_twa_graph)
vector_twa_graph.swap = new_instancemethod(_impl.vector_twa_graph_swap, None, vector_twa_graph)
vector_twa_graph.begin = new_instancemethod(_impl.vector_twa_graph_begin, None, vector_twa_graph)
vector_twa_graph.end = new_instancemethod(_impl.vector_twa_graph_end, None, vector_twa_graph)
vector_twa_graph.rbegin = new_instancemethod(_impl.vector_twa_graph_rbegin, None, vector_twa_graph)
vector_twa_graph.rend = new_instancemethod(_impl.vector_twa_graph_rend, None, vector_twa_graph)
vector_twa_graph.clear = new_instancemethod(_impl.vector_twa_graph_clear, None, vector_twa_graph)
vector_twa_graph.get_allocator = new_instancemethod(_impl.vector_twa_graph_get_allocator, None, vector_twa_graph)
vector_twa_graph.pop_back = new_instancemethod(_impl.vector_twa_graph_pop_back, None, vector_twa_graph)
vector_twa_graph.erase = new_instancemethod(_impl.vector_twa_graph_erase, None, vector_twa_graph)
vector_twa_graph.push_back = new_instancemethod(_impl.vector_twa_graph_push_back, None, vector_twa_graph)
vector_twa_graph.front = new_instancemethod(_impl.vector_twa_graph_front, None, vector_twa_graph)
vector_twa_graph.back = new_instancemethod(_impl.vector_twa_graph_back, None, vector_twa_graph)
vector_twa_graph.assign = new_instancemethod(_impl.vector_twa_graph_assign, None, vector_twa_graph)
vector_twa_graph.resize = new_instancemethod(_impl.vector_twa_graph_resize, None, vector_twa_graph)
vector_twa_graph.insert = new_instancemethod(_impl.vector_twa_graph_insert, None, vector_twa_graph)
vector_twa_graph.reserve = new_instancemethod(_impl.vector_twa_graph_reserve, None, vector_twa_graph)
vector_twa_graph.capacity = new_instancemethod(_impl.vector_twa_graph_capacity, None, vector_twa_graph)
vector_twa_graph_swigregister = _impl.vector_twa_graph_swigregister
vector_twa_graph_swigregister(vector_twa_graph)


def is_terminal_automaton(aut: 'spot::const_twa_graph_ptr const &', sm: 'scc_info'=None, ignore_trivial_scc: 'bool'=False) -> "bool":
    return _impl.is_terminal_automaton(aut, sm, ignore_trivial_scc)
is_terminal_automaton = _impl.is_terminal_automaton

def is_weak_automaton(aut: 'spot::const_twa_graph_ptr const &', sm: 'scc_info'=None) -> "bool":
    return _impl.is_weak_automaton(aut, sm)
is_weak_automaton = _impl.is_weak_automaton

def is_very_weak_automaton(aut: 'spot::const_twa_graph_ptr const &', sm: 'scc_info'=None) -> "bool":
    return _impl.is_very_weak_automaton(aut, sm)
is_very_weak_automaton = _impl.is_very_weak_automaton

def is_inherently_weak_automaton(aut: 'spot::const_twa_graph_ptr const &', sm: 'scc_info'=None) -> "bool":
    return _impl.is_inherently_weak_automaton(aut, sm)
is_inherently_weak_automaton = _impl.is_inherently_weak_automaton

def is_safety_automaton(aut: 'spot::const_twa_graph_ptr const &', sm: 'scc_info'=None) -> "bool":
    return _impl.is_safety_automaton(aut, sm)
is_safety_automaton = _impl.is_safety_automaton

def is_liveness_automaton(aut: 'spot::const_twa_graph_ptr const &') -> "bool":
    return _impl.is_liveness_automaton(aut)
is_liveness_automaton = _impl.is_liveness_automaton

def check_strength(aut: 'spot::twa_graph_ptr const &', sm: 'scc_info'=None) -> "void":
    return _impl.check_strength(aut, sm)
check_strength = _impl.check_strength

def decompose_strength(aut: 'spot::const_twa_graph_ptr const &', keep: 'char const *') -> "spot::twa_graph_ptr":
    return _impl.decompose_strength(aut, keep)
decompose_strength = _impl.decompose_strength

def decompose_scc(*args) -> "spot::twa_graph_ptr":
    return _impl.decompose_scc(*args)
decompose_scc = _impl.decompose_scc

def scc_filter(aut: 'spot::const_twa_graph_ptr const &', remove_all_useless: 'bool'=False, given_si: 'scc_info'=None) -> "spot::twa_graph_ptr":
    return _impl.scc_filter(aut, remove_all_useless, given_si)
scc_filter = _impl.scc_filter

def scc_filter_states(aut: 'spot::const_twa_graph_ptr const &', remove_all_useless: 'bool'=False, given_si: 'scc_info'=None) -> "spot::twa_graph_ptr":
    return _impl.scc_filter_states(aut, remove_all_useless, given_si)
scc_filter_states = _impl.scc_filter_states

def scc_filter_susp(aut: 'spot::const_twa_graph_ptr const &', remove_all_useless: 'bool', suspvars: 'bdd', ignoredvars: 'bdd', early_susp: 'bool', given_si: 'scc_info'=None) -> "spot::twa_graph_ptr":
    return _impl.scc_filter_susp(aut, remove_all_useless, suspvars, ignoredvars, early_susp, given_si)
scc_filter_susp = _impl.scc_filter_susp
class twa_statistics(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    edges = _swig_property(_impl.twa_statistics_edges_get, _impl.twa_statistics_edges_set)
    states = _swig_property(_impl.twa_statistics_states_get, _impl.twa_statistics_states_set)

    def __init__(self):
        _impl.twa_statistics_swiginit(self, _impl.new_twa_statistics())
    __swig_destroy__ = _impl.delete_twa_statistics
twa_statistics.dump = new_instancemethod(_impl.twa_statistics_dump, None, twa_statistics)
twa_statistics_swigregister = _impl.twa_statistics_swigregister
twa_statistics_swigregister(twa_statistics)

class twa_sub_statistics(twa_statistics):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    transitions = _swig_property(_impl.twa_sub_statistics_transitions_get, _impl.twa_sub_statistics_transitions_set)

    def __init__(self):
        _impl.twa_sub_statistics_swiginit(self, _impl.new_twa_sub_statistics())
    __swig_destroy__ = _impl.delete_twa_sub_statistics
twa_sub_statistics.dump = new_instancemethod(_impl.twa_sub_statistics_dump, None, twa_sub_statistics)
twa_sub_statistics_swigregister = _impl.twa_sub_statistics_swigregister
twa_sub_statistics_swigregister(twa_sub_statistics)


def sub_stats_reachable(g: 'spot::const_twa_ptr const &') -> "spot::twa_sub_statistics":
    return _impl.sub_stats_reachable(g)
sub_stats_reachable = _impl.sub_stats_reachable
class printable_formula(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _impl.printable_formula_swiginit(self, _impl.new_printable_formula())
    __swig_destroy__ = _impl.delete_printable_formula
printable_formula._print = new_instancemethod(_impl.printable_formula__print, None, printable_formula)
printable_formula_swigregister = _impl.printable_formula_swigregister
printable_formula_swigregister(printable_formula)

class printable_acc_cond(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _impl.printable_acc_cond_swiginit(self, _impl.new_printable_acc_cond())
    __swig_destroy__ = _impl.delete_printable_acc_cond
printable_acc_cond._print = new_instancemethod(_impl.printable_acc_cond__print, None, printable_acc_cond)
printable_acc_cond_swigregister = _impl.printable_acc_cond_swigregister
printable_acc_cond_swigregister(printable_acc_cond)

class printable_scc_info(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _impl.printable_scc_info_swiginit(self, _impl.new_printable_scc_info())
    __swig_destroy__ = _impl.delete_printable_scc_info
printable_scc_info.automaton = new_instancemethod(_impl.printable_scc_info_automaton, None, printable_scc_info)
printable_scc_info.reset = new_instancemethod(_impl.printable_scc_info_reset, None, printable_scc_info)
printable_scc_info._print = new_instancemethod(_impl.printable_scc_info__print, None, printable_scc_info)
printable_scc_info_swigregister = _impl.printable_scc_info_swigregister
printable_scc_info_swigregister(printable_scc_info)

class stat_printer(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, os: 'ostream', format: 'char const *'):
        _impl.stat_printer_swiginit(self, _impl.new_stat_printer(os, format))
    __swig_destroy__ = _impl.delete_stat_printer
stat_printer._print = new_instancemethod(_impl.stat_printer__print, None, stat_printer)
stat_printer_swigregister = _impl.stat_printer_swigregister
stat_printer_swigregister(stat_printer)


def count_nondet_states(aut: 'spot::const_twa_graph_ptr const &') -> "unsigned int":
    return _impl.count_nondet_states(aut)
count_nondet_states = _impl.count_nondet_states

def is_universal(aut: 'spot::const_twa_graph_ptr const &') -> "bool":
    return _impl.is_universal(aut)
is_universal = _impl.is_universal

def is_deterministic(aut: 'spot::const_twa_graph_ptr const &') -> "bool":
    return _impl.is_deterministic(aut)
is_deterministic = _impl.is_deterministic

def highlight_nondet_states(aut: 'spot::twa_graph_ptr &', color: 'unsigned int') -> "void":
    return _impl.highlight_nondet_states(aut, color)
highlight_nondet_states = _impl.highlight_nondet_states

def highlight_nondet_edges(aut: 'spot::twa_graph_ptr &', color: 'unsigned int') -> "void":
    return _impl.highlight_nondet_edges(aut, color)
highlight_nondet_edges = _impl.highlight_nondet_edges

def highlight_semidet_sccs(si: 'scc_info', color: 'unsigned int') -> "void":
    return _impl.highlight_semidet_sccs(si, color)
highlight_semidet_sccs = _impl.highlight_semidet_sccs

def is_complete(aut: 'spot::const_twa_graph_ptr const &') -> "bool":
    return _impl.is_complete(aut)
is_complete = _impl.is_complete

def is_semi_deterministic(aut: 'spot::const_twa_graph_ptr const &') -> "bool":
    return _impl.is_semi_deterministic(aut)
is_semi_deterministic = _impl.is_semi_deterministic

def semidet_sccs(si: 'scc_info') -> "std::vector< bool,std::allocator< bool > >":
    return _impl.semidet_sccs(si)
semidet_sccs = _impl.semidet_sccs

def check_determinism(aut: 'spot::twa_graph_ptr') -> "void":
    return _impl.check_determinism(aut)
check_determinism = _impl.check_determinism

def count_univbranch_states(aut: 'spot::const_twa_graph_ptr const &') -> "unsigned int":
    return _impl.count_univbranch_states(aut)
count_univbranch_states = _impl.count_univbranch_states

def count_univbranch_edges(aut: 'spot::const_twa_graph_ptr const &') -> "unsigned int":
    return _impl.count_univbranch_edges(aut)
count_univbranch_edges = _impl.count_univbranch_edges

def is_colored(aut: 'spot::const_twa_graph_ptr const &') -> "bool":
    return _impl.is_colored(aut)
is_colored = _impl.is_colored

def is_unambiguous(aut: 'spot::const_twa_graph_ptr const &') -> "bool":
    return _impl.is_unambiguous(aut)
is_unambiguous = _impl.is_unambiguous

def check_unambiguous(aut: 'spot::twa_graph_ptr const &') -> "bool":
    return _impl.check_unambiguous(aut)
check_unambiguous = _impl.check_unambiguous

def scc_has_rejecting_cycle(map: 'scc_info', scc: 'unsigned int') -> "bool":
    return _impl.scc_has_rejecting_cycle(map, scc)
scc_has_rejecting_cycle = _impl.scc_has_rejecting_cycle

def is_inherently_weak_scc(map: 'scc_info', scc: 'unsigned int') -> "bool":
    return _impl.is_inherently_weak_scc(map, scc)
is_inherently_weak_scc = _impl.is_inherently_weak_scc

def is_weak_scc(map: 'scc_info', scc: 'unsigned int') -> "bool":
    return _impl.is_weak_scc(map, scc)
is_weak_scc = _impl.is_weak_scc

def is_complete_scc(map: 'scc_info', scc: 'unsigned int') -> "bool":
    return _impl.is_complete_scc(map, scc)
is_complete_scc = _impl.is_complete_scc

def is_terminal_scc(map: 'scc_info', scc: 'unsigned int') -> "bool":
    return _impl.is_terminal_scc(map, scc)
is_terminal_scc = _impl.is_terminal_scc

def simulation(*args) -> "spot::twa_graph_ptr":
    return _impl.simulation(*args)
simulation = _impl.simulation

def simulation_sba(automaton: 'spot::const_twa_graph_ptr const &') -> "spot::twa_graph_ptr":
    return _impl.simulation_sba(automaton)
simulation_sba = _impl.simulation_sba

def cosimulation(automaton: 'spot::const_twa_graph_ptr const &') -> "spot::twa_graph_ptr":
    return _impl.cosimulation(automaton)
cosimulation = _impl.cosimulation

def cosimulation_sba(automaton: 'spot::const_twa_graph_ptr const &') -> "spot::twa_graph_ptr":
    return _impl.cosimulation_sba(automaton)
cosimulation_sba = _impl.cosimulation_sba

def iterated_simulations(automaton: 'spot::const_twa_graph_ptr const &') -> "spot::twa_graph_ptr":
    return _impl.iterated_simulations(automaton)
iterated_simulations = _impl.iterated_simulations

def iterated_simulations_sba(automaton: 'spot::const_twa_graph_ptr const &') -> "spot::twa_graph_ptr":
    return _impl.iterated_simulations_sba(automaton)
iterated_simulations_sba = _impl.iterated_simulations_sba
parity_kind_max = _impl.parity_kind_max
parity_kind_min = _impl.parity_kind_min
parity_kind_same = _impl.parity_kind_same
parity_kind_any = _impl.parity_kind_any
parity_style_odd = _impl.parity_style_odd
parity_style_even = _impl.parity_style_even
parity_style_same = _impl.parity_style_same
parity_style_any = _impl.parity_style_any

def change_parity(aut: 'spot::const_twa_graph_ptr const &', kind: 'spot::parity_kind', style: 'spot::parity_style') -> "spot::twa_graph_ptr":
    return _impl.change_parity(aut, kind, style)
change_parity = _impl.change_parity

def change_parity_here(aut: 'spot::twa_graph_ptr', kind: 'spot::parity_kind', style: 'spot::parity_style') -> "spot::twa_graph_ptr":
    return _impl.change_parity_here(aut, kind, style)
change_parity_here = _impl.change_parity_here

def cleanup_parity(aut: 'spot::const_twa_graph_ptr const &', keep_style: 'bool'=False) -> "spot::twa_graph_ptr":
    return _impl.cleanup_parity(aut, keep_style)
cleanup_parity = _impl.cleanup_parity

def cleanup_parity_here(aut: 'spot::twa_graph_ptr', keep_style: 'bool'=False) -> "spot::twa_graph_ptr":
    return _impl.cleanup_parity_here(aut, keep_style)
cleanup_parity_here = _impl.cleanup_parity_here

def colorize_parity(aut: 'spot::const_twa_graph_ptr const &', keep_style: 'bool'=False) -> "spot::twa_graph_ptr":
    return _impl.colorize_parity(aut, keep_style)
colorize_parity = _impl.colorize_parity

def colorize_parity_here(aut: 'spot::twa_graph_ptr', keep_style: 'bool'=False) -> "spot::twa_graph_ptr":
    return _impl.colorize_parity_here(aut, keep_style)
colorize_parity_here = _impl.colorize_parity_here

def reduce_parity(aut: 'spot::const_twa_graph_ptr const &', colored: 'bool'=False) -> "spot::twa_graph_ptr":
    return _impl.reduce_parity(aut, colored)
reduce_parity = _impl.reduce_parity

def reduce_parity_here(aut: 'spot::twa_graph_ptr', colored: 'bool'=False) -> "spot::twa_graph_ptr":
    return _impl.reduce_parity_here(aut, colored)
reduce_parity_here = _impl.reduce_parity_here
class postprocessor(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, opt: 'option_map'=None):
        _impl.postprocessor_swiginit(self, _impl.new_postprocessor(opt))
    TGBA = _impl.postprocessor_TGBA
    BA = _impl.postprocessor_BA
    Monitor = _impl.postprocessor_Monitor
    Generic = _impl.postprocessor_Generic
    Parity = _impl.postprocessor_Parity
    ParityMin = _impl.postprocessor_ParityMin
    ParityMax = _impl.postprocessor_ParityMax
    ParityOdd = _impl.postprocessor_ParityOdd
    ParityEven = _impl.postprocessor_ParityEven
    ParityMinOdd = _impl.postprocessor_ParityMinOdd
    ParityMaxOdd = _impl.postprocessor_ParityMaxOdd
    ParityMinEven = _impl.postprocessor_ParityMinEven
    ParityMaxEven = _impl.postprocessor_ParityMaxEven
    CoBuchi = _impl.postprocessor_CoBuchi
    Any = _impl.postprocessor_Any
    Small = _impl.postprocessor_Small
    Deterministic = _impl.postprocessor_Deterministic
    Complete = _impl.postprocessor_Complete
    SBAcc = _impl.postprocessor_SBAcc
    Unambiguous = _impl.postprocessor_Unambiguous
    Colored = _impl.postprocessor_Colored
    Low = _impl.postprocessor_Low
    Medium = _impl.postprocessor_Medium
    High = _impl.postprocessor_High
    __swig_destroy__ = _impl.delete_postprocessor
postprocessor.set_type = new_instancemethod(_impl.postprocessor_set_type, None, postprocessor)
postprocessor.set_pref = new_instancemethod(_impl.postprocessor_set_pref, None, postprocessor)
postprocessor.set_level = new_instancemethod(_impl.postprocessor_set_level, None, postprocessor)
postprocessor.run = new_instancemethod(_impl.postprocessor_run, None, postprocessor)
postprocessor_swigregister = _impl.postprocessor_swigregister
postprocessor_swigregister(postprocessor)

class power_map(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    map_ = _swig_property(_impl.power_map_map__get, _impl.power_map_map__set)

    def __init__(self):
        _impl.power_map_swiginit(self, _impl.new_power_map())
    __swig_destroy__ = _impl.delete_power_map
power_map.states_of = new_instancemethod(_impl.power_map_states_of, None, power_map)
power_map_swigregister = _impl.power_map_swigregister
power_map_swigregister(power_map)

class output_aborter(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _impl.output_aborter_swiginit(self, _impl.new_output_aborter(*args))
    __swig_destroy__ = _impl.delete_output_aborter
output_aborter.max_states = new_instancemethod(_impl.output_aborter_max_states, None, output_aborter)
output_aborter.max_edges = new_instancemethod(_impl.output_aborter_max_edges, None, output_aborter)
output_aborter.too_large = new_instancemethod(_impl.output_aborter_too_large, None, output_aborter)
output_aborter.print_reason = new_instancemethod(_impl.output_aborter_print_reason, None, output_aborter)
output_aborter_swigregister = _impl.output_aborter_swigregister
output_aborter_swigregister(output_aborter)


def tgba_powerset(*args) -> "spot::twa_graph_ptr":
    return _impl.tgba_powerset(*args)
tgba_powerset = _impl.tgba_powerset

def tba_determinize(aut: 'spot::const_twa_graph_ptr const &', threshold_states: 'unsigned int'=0, threshold_cycles: 'unsigned int'=0) -> "spot::twa_graph_ptr":
    return _impl.tba_determinize(aut, threshold_states, threshold_cycles)
tba_determinize = _impl.tba_determinize

def tba_determinize_check(aut: 'spot::twa_graph_ptr const &', threshold_states: 'unsigned int'=0, threshold_cycles: 'unsigned int'=0, f: 'formula'=0, neg_aut: 'spot::const_twa_graph_ptr'=0) -> "spot::twa_graph_ptr":
    return _impl.tba_determinize_check(aut, threshold_states, threshold_cycles, f, neg_aut)
tba_determinize_check = _impl.tba_determinize_check

def product(*args) -> "spot::twa_graph_ptr":
    return _impl.product(*args)
product = _impl.product

def product_or(*args) -> "spot::twa_graph_ptr":
    return _impl.product_or(*args)
product_or = _impl.product_or

def product_xor(left: 'spot::const_twa_graph_ptr const &', right: 'spot::const_twa_graph_ptr const &') -> "spot::twa_graph_ptr":
    return _impl.product_xor(left, right)
product_xor = _impl.product_xor

def product_xnor(left: 'spot::const_twa_graph_ptr const &', right: 'spot::const_twa_graph_ptr const &') -> "spot::twa_graph_ptr":
    return _impl.product_xnor(left, right)
product_xnor = _impl.product_xnor

def product_susp(left: 'spot::const_twa_graph_ptr const &', right_susp: 'spot::const_twa_graph_ptr const &') -> "spot::twa_graph_ptr":
    return _impl.product_susp(left, right_susp)
product_susp = _impl.product_susp

def product_or_susp(left: 'spot::const_twa_graph_ptr const &', right_susp: 'spot::const_twa_graph_ptr const &') -> "spot::twa_graph_ptr":
    return _impl.product_or_susp(left, right_susp)
product_or_susp = _impl.product_or_susp

def split_edges(aut: 'spot::const_twa_graph_ptr const &') -> "spot::twa_graph_ptr":
    return _impl.split_edges(aut)
split_edges = _impl.split_edges

def split_2step(aut: 'spot::const_twa_graph_ptr const &', input_bdd: 'bdd') -> "spot::twa_graph_ptr":
    return _impl.split_2step(aut, input_bdd)
split_2step = _impl.split_2step

def unsplit_2step(aut: 'spot::const_twa_graph_ptr const &') -> "spot::twa_graph_ptr":
    return _impl.unsplit_2step(aut)
unsplit_2step = _impl.unsplit_2step

def sum(*args) -> "spot::twa_graph_ptr":
    return _impl.sum(*args)
sum = _impl.sum

def sum_and(*args) -> "spot::twa_graph_ptr":
    return _impl.sum_and(*args)
sum_and = _impl.sum_and

def sl(aut: 'spot::const_twa_graph_ptr') -> "spot::twa_graph_ptr":
    return _impl.sl(aut)
sl = _impl.sl

def sl2_inplace(aut: 'spot::twa_graph_ptr') -> "spot::twa_graph_ptr":
    return _impl.sl2_inplace(aut)
sl2_inplace = _impl.sl2_inplace

def sl2(aut: 'spot::const_twa_graph_ptr') -> "spot::twa_graph_ptr":
    return _impl.sl2(aut)
sl2 = _impl.sl2

def closure_inplace(aut: 'spot::twa_graph_ptr') -> "spot::twa_graph_ptr":
    return _impl.closure_inplace(aut)
closure_inplace = _impl.closure_inplace

def closure(aut: 'spot::const_twa_graph_ptr') -> "spot::twa_graph_ptr":
    return _impl.closure(aut)
closure = _impl.closure

def is_stutter_invariant(*args) -> "bool":
    return _impl.is_stutter_invariant(*args)
is_stutter_invariant = _impl.is_stutter_invariant

def check_stutter_invariance(aut_f: 'spot::twa_graph_ptr', f: 'formula'=0, do_not_determinize: 'bool'=False, find_counterexamples: 'bool'=False) -> "spot::trival":
    return _impl.check_stutter_invariance(aut_f, f, do_not_determinize, find_counterexamples)
check_stutter_invariance = _impl.check_stutter_invariance

def stutter_invariant_states(*args) -> "std::vector< bool,std::allocator< bool > >":
    return _impl.stutter_invariant_states(*args)
stutter_invariant_states = _impl.stutter_invariant_states

def highlight_stutter_invariant_states(*args) -> "void":
    return _impl.highlight_stutter_invariant_states(*args)
highlight_stutter_invariant_states = _impl.highlight_stutter_invariant_states

def stutter_invariant_letters(*args) -> "std::vector< bdd,std::allocator< bdd > >":
    return _impl.stutter_invariant_letters(*args)
stutter_invariant_letters = _impl.stutter_invariant_letters

def is_stutter_invariant_forward_closed(aut: 'spot::twa_graph_ptr', sistates: 'vectorbool') -> "int":
    return _impl.is_stutter_invariant_forward_closed(aut, sistates)
is_stutter_invariant_forward_closed = _impl.is_stutter_invariant_forward_closed

def make_stutter_invariant_forward_closed_inplace(aut: 'spot::twa_graph_ptr', sistates: 'vectorbool') -> "std::vector< bool,std::allocator< bool > >":
    return _impl.make_stutter_invariant_forward_closed_inplace(aut, sistates)
make_stutter_invariant_forward_closed_inplace = _impl.make_stutter_invariant_forward_closed_inplace
class translator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _impl.translator_swiginit(self, _impl.new_translator(*args))
    __swig_destroy__ = _impl.delete_translator
translator.set_type = new_instancemethod(_impl.translator_set_type, None, translator)
translator.set_pref = new_instancemethod(_impl.translator_set_pref, None, translator)
translator.set_level = new_instancemethod(_impl.translator_set_level, None, translator)
translator.run = new_instancemethod(_impl.translator_run, None, translator)
translator.clear_caches = new_instancemethod(_impl.translator_clear_caches, None, translator)
translator_swigregister = _impl.translator_swigregister
translator_swigregister(translator)


def to_weak_alternating(aut: 'spot::const_twa_graph_ptr &', less: 'bool'=False) -> "spot::twa_graph_ptr":
    return _impl.to_weak_alternating(aut, less)
to_weak_alternating = _impl.to_weak_alternating

def print_hoa(os: 'ostream', g: 'spot::const_twa_ptr const &', opt: 'char const *'=None) -> "std::ostream &":
    return _impl.print_hoa(os, g, opt)
print_hoa = _impl.print_hoa

def dtwa_sat_synthetize(a: 'spot::const_twa_graph_ptr const &', target_acc_number: 'unsigned int', target_acc: 'acc_code', target_state_number: 'int', state_based: 'bool'=False, colored: 'bool'=False) -> "spot::twa_graph_ptr":
    return _impl.dtwa_sat_synthetize(a, target_acc_number, target_acc, target_state_number, state_based, colored)
dtwa_sat_synthetize = _impl.dtwa_sat_synthetize

def dtwa_sat_minimize(a: 'spot::const_twa_graph_ptr const &', target_acc_number: 'unsigned int', target_acc: 'acc_code', state_based: 'bool'=False, max_states: 'int'=-1, colored: 'bool'=False) -> "spot::twa_graph_ptr":
    return _impl.dtwa_sat_minimize(a, target_acc_number, target_acc, state_based, max_states, colored)
dtwa_sat_minimize = _impl.dtwa_sat_minimize

def dtwa_sat_minimize_dichotomy(a: 'spot::const_twa_graph_ptr const &', target_acc_number: 'unsigned int', target_acc: 'acc_code', state_based: 'bool'=False, langmap: 'bool'=False, max_states: 'int'=-1, colored: 'bool'=False) -> "spot::twa_graph_ptr":
    return _impl.dtwa_sat_minimize_dichotomy(a, target_acc_number, target_acc, state_based, langmap, max_states, colored)
dtwa_sat_minimize_dichotomy = _impl.dtwa_sat_minimize_dichotomy

def dtwa_sat_minimize_incr(a: 'spot::const_twa_graph_ptr const &', target_acc_number: 'unsigned int', target_acc: 'acc_code', state_based: 'bool'=False, max_states: 'int'=-1, colored: 'bool'=False, param: 'int'=2) -> "spot::twa_graph_ptr":
    return _impl.dtwa_sat_minimize_incr(a, target_acc_number, target_acc, state_based, max_states, colored, param)
dtwa_sat_minimize_incr = _impl.dtwa_sat_minimize_incr

def dtwa_sat_minimize_assume(a: 'spot::const_twa_graph_ptr const &', target_acc_number: 'unsigned int', target_acc: 'acc_code', state_based: 'bool'=False, max_states: 'int'=-1, colored: 'bool'=False, param: 'int'=6) -> "spot::twa_graph_ptr":
    return _impl.dtwa_sat_minimize_assume(a, target_acc_number, target_acc, state_based, max_states, colored, param)
dtwa_sat_minimize_assume = _impl.dtwa_sat_minimize_assume

def sat_minimize(aut: 'spot::twa_graph_ptr', opt: 'char const *', state_based: 'bool'=False) -> "spot::twa_graph_ptr":
    return _impl.sat_minimize(aut, opt, state_based)
sat_minimize = _impl.sat_minimize

def relabel_here(aut: 'spot::twa_graph_ptr &', relmap: 'relabeling_map') -> "void":
    return _impl.relabel_here(aut, relmap)
relabel_here = _impl.relabel_here
class twa_word(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _impl.twa_word_swiginit(self, _impl.new_twa_word(*args))
    __swig_destroy__ = _impl.delete_twa_word
    prefix = _swig_property(_impl.twa_word_prefix_get, _impl.twa_word_prefix_set)
    cycle = _swig_property(_impl.twa_word_cycle_get, _impl.twa_word_cycle_set)
twa_word.simplify = new_instancemethod(_impl.twa_word_simplify, None, twa_word)
twa_word.use_all_aps = new_instancemethod(_impl.twa_word_use_all_aps, None, twa_word)
twa_word.get_dict = new_instancemethod(_impl.twa_word_get_dict, None, twa_word)
twa_word.as_automaton = new_instancemethod(_impl.twa_word_as_automaton, None, twa_word)
twa_word.__str__ = new_instancemethod(_impl.twa_word___str__, None, twa_word)
twa_word_swigregister = _impl.twa_word_swigregister
twa_word_swigregister(twa_word)


def make_twa_word(*args) -> "spot::twa_word_ptr":
    return _impl.make_twa_word(*args)
make_twa_word = _impl.make_twa_word

def parse_word(word: 'std::string const &', dict: 'spot::bdd_dict_ptr const &') -> "spot::twa_word_ptr":
    return _impl.parse_word(word, dict)
parse_word = _impl.parse_word
class list_bdd(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __iter__(self):
        return self.iterator()

    def __init__(self, *args):
        _impl.list_bdd_swiginit(self, _impl.new_list_bdd(*args))
    __swig_destroy__ = _impl.delete_list_bdd
list_bdd.iterator = new_instancemethod(_impl.list_bdd_iterator, None, list_bdd)
list_bdd.__nonzero__ = new_instancemethod(_impl.list_bdd___nonzero__, None, list_bdd)
list_bdd.__bool__ = new_instancemethod(_impl.list_bdd___bool__, None, list_bdd)
list_bdd.__len__ = new_instancemethod(_impl.list_bdd___len__, None, list_bdd)
list_bdd.__getslice__ = new_instancemethod(_impl.list_bdd___getslice__, None, list_bdd)
list_bdd.__setslice__ = new_instancemethod(_impl.list_bdd___setslice__, None, list_bdd)
list_bdd.__delslice__ = new_instancemethod(_impl.list_bdd___delslice__, None, list_bdd)
list_bdd.__delitem__ = new_instancemethod(_impl.list_bdd___delitem__, None, list_bdd)
list_bdd.__getitem__ = new_instancemethod(_impl.list_bdd___getitem__, None, list_bdd)
list_bdd.__setitem__ = new_instancemethod(_impl.list_bdd___setitem__, None, list_bdd)
list_bdd.pop = new_instancemethod(_impl.list_bdd_pop, None, list_bdd)
list_bdd.append = new_instancemethod(_impl.list_bdd_append, None, list_bdd)
list_bdd.empty = new_instancemethod(_impl.list_bdd_empty, None, list_bdd)
list_bdd.size = new_instancemethod(_impl.list_bdd_size, None, list_bdd)
list_bdd.swap = new_instancemethod(_impl.list_bdd_swap, None, list_bdd)
list_bdd.begin = new_instancemethod(_impl.list_bdd_begin, None, list_bdd)
list_bdd.end = new_instancemethod(_impl.list_bdd_end, None, list_bdd)
list_bdd.rbegin = new_instancemethod(_impl.list_bdd_rbegin, None, list_bdd)
list_bdd.rend = new_instancemethod(_impl.list_bdd_rend, None, list_bdd)
list_bdd.clear = new_instancemethod(_impl.list_bdd_clear, None, list_bdd)
list_bdd.get_allocator = new_instancemethod(_impl.list_bdd_get_allocator, None, list_bdd)
list_bdd.pop_back = new_instancemethod(_impl.list_bdd_pop_back, None, list_bdd)
list_bdd.erase = new_instancemethod(_impl.list_bdd_erase, None, list_bdd)
list_bdd.push_back = new_instancemethod(_impl.list_bdd_push_back, None, list_bdd)
list_bdd.front = new_instancemethod(_impl.list_bdd_front, None, list_bdd)
list_bdd.back = new_instancemethod(_impl.list_bdd_back, None, list_bdd)
list_bdd.assign = new_instancemethod(_impl.list_bdd_assign, None, list_bdd)
list_bdd.resize = new_instancemethod(_impl.list_bdd_resize, None, list_bdd)
list_bdd.insert = new_instancemethod(_impl.list_bdd_insert, None, list_bdd)
list_bdd.pop_front = new_instancemethod(_impl.list_bdd_pop_front, None, list_bdd)
list_bdd.push_front = new_instancemethod(_impl.list_bdd_push_front, None, list_bdd)
list_bdd.reverse = new_instancemethod(_impl.list_bdd_reverse, None, list_bdd)
list_bdd_swigregister = _impl.list_bdd_swigregister
list_bdd_swigregister(list_bdd)

class isomorphism_checker(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, ref: 'spot::const_twa_graph_ptr const'):
        _impl.isomorphism_checker_swiginit(self, _impl.new_isomorphism_checker(ref))
    are_isomorphic = staticmethod(_impl.isomorphism_checker_are_isomorphic)
    __swig_destroy__ = _impl.delete_isomorphism_checker
isomorphism_checker.is_isomorphic = new_instancemethod(_impl.isomorphism_checker_is_isomorphic, None, isomorphism_checker)
isomorphism_checker_swigregister = _impl.isomorphism_checker_swigregister
isomorphism_checker_swigregister(isomorphism_checker)

def isomorphism_checker_are_isomorphic(ref: 'spot::const_twa_graph_ptr const', aut: 'spot::const_twa_graph_ptr const') -> "bool":
    return _impl.isomorphism_checker_are_isomorphic(ref, aut)
isomorphism_checker_are_isomorphic = _impl.isomorphism_checker_are_isomorphic

class to_parity_options(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    search_ex = _swig_property(_impl.to_parity_options_search_ex_get, _impl.to_parity_options_search_ex_set)
    use_last = _swig_property(_impl.to_parity_options_use_last_get, _impl.to_parity_options_use_last_set)
    force_order = _swig_property(_impl.to_parity_options_force_order_get, _impl.to_parity_options_force_order_set)
    partial_degen = _swig_property(_impl.to_parity_options_partial_degen_get, _impl.to_parity_options_partial_degen_set)
    force_degen = _swig_property(_impl.to_parity_options_force_degen_get, _impl.to_parity_options_force_degen_set)
    acc_clean = _swig_property(_impl.to_parity_options_acc_clean_get, _impl.to_parity_options_acc_clean_set)
    parity_equiv = _swig_property(_impl.to_parity_options_parity_equiv_get, _impl.to_parity_options_parity_equiv_set)
    parity_prefix = _swig_property(_impl.to_parity_options_parity_prefix_get, _impl.to_parity_options_parity_prefix_set)
    rabin_to_buchi = _swig_property(_impl.to_parity_options_rabin_to_buchi_get, _impl.to_parity_options_rabin_to_buchi_set)
    reduce_col_deg = _swig_property(_impl.to_parity_options_reduce_col_deg_get, _impl.to_parity_options_reduce_col_deg_set)
    propagate_col = _swig_property(_impl.to_parity_options_propagate_col_get, _impl.to_parity_options_propagate_col_set)
    pretty_print = _swig_property(_impl.to_parity_options_pretty_print_get, _impl.to_parity_options_pretty_print_set)

    def __init__(self):
        _impl.to_parity_options_swiginit(self, _impl.new_to_parity_options())
    __swig_destroy__ = _impl.delete_to_parity_options
to_parity_options_swigregister = _impl.to_parity_options_swigregister
to_parity_options_swigregister(to_parity_options)


def to_parity(*args) -> "spot::twa_graph_ptr":
    return _impl.to_parity(*args)
to_parity = _impl.to_parity

def to_parity_old(aut: 'spot::const_twa_graph_ptr const &', pretty_print: 'bool'=False) -> "spot::twa_graph_ptr":
    return _impl.to_parity_old(aut, pretty_print)
to_parity_old = _impl.to_parity_old

def iar(aut: 'spot::const_twa_graph_ptr const &', pretty_print: 'bool'=False) -> "spot::twa_graph_ptr":
    return _impl.iar(aut, pretty_print)
iar = _impl.iar

def iar_maybe(aut: 'spot::const_twa_graph_ptr const &', pretty_print: 'bool'=False) -> "spot::twa_graph_ptr":
    return _impl.iar_maybe(aut, pretty_print)
iar_maybe = _impl.iar_maybe

def dtwa_complement(aut: 'spot::const_twa_graph_ptr const &') -> "spot::twa_graph_ptr":
    return _impl.dtwa_complement(aut)
dtwa_complement = _impl.dtwa_complement

def complement_semidet(aut: 'spot::const_twa_graph_ptr const &', show_names: 'bool'=False) -> "spot::twa_graph_ptr":
    return _impl.complement_semidet(aut, show_names)
complement_semidet = _impl.complement_semidet

def complement(aut: 'spot::const_twa_graph_ptr const &', aborter: 'output_aborter'=None) -> "spot::twa_graph_ptr":
    return _impl.complement(aut, aborter)
complement = _impl.complement
class fair_kripke_succ_iterator(twa_succ_iterator):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _impl.delete_fair_kripke_succ_iterator
fair_kripke_succ_iterator_swigregister = _impl.fair_kripke_succ_iterator_swigregister
fair_kripke_succ_iterator_swigregister(fair_kripke_succ_iterator)

class fair_kripke(twa):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _impl.delete_fair_kripke
fair_kripke.state_condition = new_instancemethod(_impl.fair_kripke_state_condition, None, fair_kripke)
fair_kripke.state_acceptance_mark = new_instancemethod(_impl.fair_kripke_state_acceptance_mark, None, fair_kripke)
fair_kripke_swigregister = _impl.fair_kripke_swigregister
fair_kripke_swigregister(fair_kripke)

class kripke_succ_iterator(twa_succ_iterator):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _impl.delete_kripke_succ_iterator
kripke_succ_iterator.recycle = new_instancemethod(_impl.kripke_succ_iterator_recycle, None, kripke_succ_iterator)
kripke_succ_iterator_swigregister = _impl.kripke_succ_iterator_swigregister
kripke_succ_iterator_swigregister(kripke_succ_iterator)

class kripke(fair_kripke):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _impl.delete_kripke
kripke_swigregister = _impl.kripke_swigregister
kripke_swigregister(kripke)

class kripke_graph_state(state):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _impl.kripke_graph_state_swiginit(self, _impl.new_kripke_graph_state(*args))
    __swig_destroy__ = _impl.delete_kripke_graph_state
kripke_graph_state.clone = new_instancemethod(_impl.kripke_graph_state_clone, None, kripke_graph_state)
kripke_graph_state.cond = new_instancemethod(_impl.kripke_graph_state_cond, None, kripke_graph_state)
kripke_graph_state_swigregister = _impl.kripke_graph_state_swigregister
kripke_graph_state_swigregister(kripke_graph_state)

class kripke_graph(kripke):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, d: 'spot::bdd_dict_ptr const &'):
        _impl.kripke_graph_swiginit(self, _impl.new_kripke_graph(d))
    __swig_destroy__ = _impl.delete_kripke_graph
kripke_graph.num_states = new_instancemethod(_impl.kripke_graph_num_states, None, kripke_graph)
kripke_graph.num_edges = new_instancemethod(_impl.kripke_graph_num_edges, None, kripke_graph)
kripke_graph.set_init_state = new_instancemethod(_impl.kripke_graph_set_init_state, None, kripke_graph)
kripke_graph.get_init_state_number = new_instancemethod(_impl.kripke_graph_get_init_state_number, None, kripke_graph)
kripke_graph.get_init_state = new_instancemethod(_impl.kripke_graph_get_init_state, None, kripke_graph)
kripke_graph.succ_iter = new_instancemethod(_impl.kripke_graph_succ_iter, None, kripke_graph)
kripke_graph.state_number = new_instancemethod(_impl.kripke_graph_state_number, None, kripke_graph)
kripke_graph.state_from_number = new_instancemethod(_impl.kripke_graph_state_from_number, None, kripke_graph)
kripke_graph.format_state = new_instancemethod(_impl.kripke_graph_format_state, None, kripke_graph)
kripke_graph.edge_storage = new_instancemethod(_impl.kripke_graph_edge_storage, None, kripke_graph)
kripke_graph.new_state = new_instancemethod(_impl.kripke_graph_new_state, None, kripke_graph)
kripke_graph.new_states = new_instancemethod(_impl.kripke_graph_new_states, None, kripke_graph)
kripke_graph.new_edge = new_instancemethod(_impl.kripke_graph_new_edge, None, kripke_graph)
kripke_graph.states = new_instancemethod(_impl.kripke_graph_states, None, kripke_graph)
kripke_graph.edges = new_instancemethod(_impl.kripke_graph_edges, None, kripke_graph)
kripke_graph.out = new_instancemethod(_impl.kripke_graph_out, None, kripke_graph)
kripke_graph_swigregister = _impl.kripke_graph_swigregister
kripke_graph_swigregister(kripke_graph)


def make_kripke_graph(d: 'spot::bdd_dict_ptr const &') -> "spot::kripke_graph_ptr":
    return _impl.make_kripke_graph(d)
make_kripke_graph = _impl.make_kripke_graph
class kripke_graph_state_out(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, g: 'spot::digraph< spot::kripke_graph_state,void > *', t: 'spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > >::edge'):
        _impl.kripke_graph_state_out_swiginit(self, _impl.new_kripke_graph_state_out(g, t))
    __swig_destroy__ = _impl.delete_kripke_graph_state_out
kripke_graph_state_out.begin = new_instancemethod(_impl.kripke_graph_state_out_begin, None, kripke_graph_state_out)
kripke_graph_state_out.end = new_instancemethod(_impl.kripke_graph_state_out_end, None, kripke_graph_state_out)
kripke_graph_state_out.recycle = new_instancemethod(_impl.kripke_graph_state_out_recycle, None, kripke_graph_state_out)
kripke_graph_state_out.__iter__ = new_instancemethod(_impl.kripke_graph_state_out___iter__, None, kripke_graph_state_out)
kripke_graph_state_out_swigregister = _impl.kripke_graph_state_out_swigregister
kripke_graph_state_out_swigregister(kripke_graph_state_out)

class kripke_graph_all_trans(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, tv: 'spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > >::tv_t &'):
        _impl.kripke_graph_all_trans_swiginit(self, _impl.new_kripke_graph_all_trans(tv))
    __swig_destroy__ = _impl.delete_kripke_graph_all_trans
kripke_graph_all_trans.begin = new_instancemethod(_impl.kripke_graph_all_trans_begin, None, kripke_graph_all_trans)
kripke_graph_all_trans.end = new_instancemethod(_impl.kripke_graph_all_trans_end, None, kripke_graph_all_trans)
kripke_graph_all_trans.__iter__ = new_instancemethod(_impl.kripke_graph_all_trans___iter__, None, kripke_graph_all_trans)
kripke_graph_all_trans_swigregister = _impl.kripke_graph_all_trans_swigregister
kripke_graph_all_trans_swigregister(kripke_graph_all_trans)

class kripke_graph_edge_boxed_data(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _impl.kripke_graph_edge_boxed_data_swiginit(self, _impl.new_kripke_graph_edge_boxed_data())
    __swig_destroy__ = _impl.delete_kripke_graph_edge_boxed_data
kripke_graph_edge_boxed_data.data = new_instancemethod(_impl.kripke_graph_edge_boxed_data_data, None, kripke_graph_edge_boxed_data)
kripke_graph_edge_boxed_data_swigregister = _impl.kripke_graph_edge_boxed_data_swigregister
kripke_graph_edge_boxed_data_swigregister(kripke_graph_edge_boxed_data)

class kripke_graph_edge_storage(kripke_graph_edge_boxed_data):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    dst = _swig_property(_impl.kripke_graph_edge_storage_dst_get, _impl.kripke_graph_edge_storage_dst_set)
    next_succ = _swig_property(_impl.kripke_graph_edge_storage_next_succ_get, _impl.kripke_graph_edge_storage_next_succ_set)
    src = _swig_property(_impl.kripke_graph_edge_storage_src_get, _impl.kripke_graph_edge_storage_src_set)

    def __init__(self):
        _impl.kripke_graph_edge_storage_swiginit(self, _impl.new_kripke_graph_edge_storage())
    __swig_destroy__ = _impl.delete_kripke_graph_edge_storage
kripke_graph_edge_storage.__lt__ = new_instancemethod(_impl.kripke_graph_edge_storage___lt__, None, kripke_graph_edge_storage)
kripke_graph_edge_storage.__eq__ = new_instancemethod(_impl.kripke_graph_edge_storage___eq__, None, kripke_graph_edge_storage)
kripke_graph_edge_storage_swigregister = _impl.kripke_graph_edge_storage_swigregister
kripke_graph_edge_storage_swigregister(kripke_graph_edge_storage)

class kripke_graph_state_boxed_data(kripke_graph_state):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _impl.kripke_graph_state_boxed_data_swiginit(self, _impl.new_kripke_graph_state_boxed_data())
    __swig_destroy__ = _impl.delete_kripke_graph_state_boxed_data
kripke_graph_state_boxed_data.data = new_instancemethod(_impl.kripke_graph_state_boxed_data_data, None, kripke_graph_state_boxed_data)
kripke_graph_state_boxed_data_swigregister = _impl.kripke_graph_state_boxed_data_swigregister
kripke_graph_state_boxed_data_swigregister(kripke_graph_state_boxed_data)

class kripke_graph_state_storage(kripke_graph_state_boxed_data):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    succ = _swig_property(_impl.kripke_graph_state_storage_succ_get, _impl.kripke_graph_state_storage_succ_set)
    succ_tail = _swig_property(_impl.kripke_graph_state_storage_succ_tail_get, _impl.kripke_graph_state_storage_succ_tail_set)

    def __init__(self):
        _impl.kripke_graph_state_storage_swiginit(self, _impl.new_kripke_graph_state_storage())
    __swig_destroy__ = _impl.delete_kripke_graph_state_storage
kripke_graph_state_storage_swigregister = _impl.kripke_graph_state_storage_swigregister
kripke_graph_state_storage_swigregister(kripke_graph_state_storage)

class kripke_graph_state_vector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __iter__(self):
        return self.iterator()

    def __init__(self, *args):
        _impl.kripke_graph_state_vector_swiginit(self, _impl.new_kripke_graph_state_vector(*args))
    __swig_destroy__ = _impl.delete_kripke_graph_state_vector
kripke_graph_state_vector.iterator = new_instancemethod(_impl.kripke_graph_state_vector_iterator, None, kripke_graph_state_vector)
kripke_graph_state_vector.__nonzero__ = new_instancemethod(_impl.kripke_graph_state_vector___nonzero__, None, kripke_graph_state_vector)
kripke_graph_state_vector.__bool__ = new_instancemethod(_impl.kripke_graph_state_vector___bool__, None, kripke_graph_state_vector)
kripke_graph_state_vector.__len__ = new_instancemethod(_impl.kripke_graph_state_vector___len__, None, kripke_graph_state_vector)
kripke_graph_state_vector.__getslice__ = new_instancemethod(_impl.kripke_graph_state_vector___getslice__, None, kripke_graph_state_vector)
kripke_graph_state_vector.__setslice__ = new_instancemethod(_impl.kripke_graph_state_vector___setslice__, None, kripke_graph_state_vector)
kripke_graph_state_vector.__delslice__ = new_instancemethod(_impl.kripke_graph_state_vector___delslice__, None, kripke_graph_state_vector)
kripke_graph_state_vector.__delitem__ = new_instancemethod(_impl.kripke_graph_state_vector___delitem__, None, kripke_graph_state_vector)
kripke_graph_state_vector.__getitem__ = new_instancemethod(_impl.kripke_graph_state_vector___getitem__, None, kripke_graph_state_vector)
kripke_graph_state_vector.__setitem__ = new_instancemethod(_impl.kripke_graph_state_vector___setitem__, None, kripke_graph_state_vector)
kripke_graph_state_vector.pop = new_instancemethod(_impl.kripke_graph_state_vector_pop, None, kripke_graph_state_vector)
kripke_graph_state_vector.append = new_instancemethod(_impl.kripke_graph_state_vector_append, None, kripke_graph_state_vector)
kripke_graph_state_vector.empty = new_instancemethod(_impl.kripke_graph_state_vector_empty, None, kripke_graph_state_vector)
kripke_graph_state_vector.size = new_instancemethod(_impl.kripke_graph_state_vector_size, None, kripke_graph_state_vector)
kripke_graph_state_vector.swap = new_instancemethod(_impl.kripke_graph_state_vector_swap, None, kripke_graph_state_vector)
kripke_graph_state_vector.begin = new_instancemethod(_impl.kripke_graph_state_vector_begin, None, kripke_graph_state_vector)
kripke_graph_state_vector.end = new_instancemethod(_impl.kripke_graph_state_vector_end, None, kripke_graph_state_vector)
kripke_graph_state_vector.rbegin = new_instancemethod(_impl.kripke_graph_state_vector_rbegin, None, kripke_graph_state_vector)
kripke_graph_state_vector.rend = new_instancemethod(_impl.kripke_graph_state_vector_rend, None, kripke_graph_state_vector)
kripke_graph_state_vector.clear = new_instancemethod(_impl.kripke_graph_state_vector_clear, None, kripke_graph_state_vector)
kripke_graph_state_vector.get_allocator = new_instancemethod(_impl.kripke_graph_state_vector_get_allocator, None, kripke_graph_state_vector)
kripke_graph_state_vector.pop_back = new_instancemethod(_impl.kripke_graph_state_vector_pop_back, None, kripke_graph_state_vector)
kripke_graph_state_vector.erase = new_instancemethod(_impl.kripke_graph_state_vector_erase, None, kripke_graph_state_vector)
kripke_graph_state_vector.push_back = new_instancemethod(_impl.kripke_graph_state_vector_push_back, None, kripke_graph_state_vector)
kripke_graph_state_vector.front = new_instancemethod(_impl.kripke_graph_state_vector_front, None, kripke_graph_state_vector)
kripke_graph_state_vector.back = new_instancemethod(_impl.kripke_graph_state_vector_back, None, kripke_graph_state_vector)
kripke_graph_state_vector.assign = new_instancemethod(_impl.kripke_graph_state_vector_assign, None, kripke_graph_state_vector)
kripke_graph_state_vector.resize = new_instancemethod(_impl.kripke_graph_state_vector_resize, None, kripke_graph_state_vector)
kripke_graph_state_vector.insert = new_instancemethod(_impl.kripke_graph_state_vector_insert, None, kripke_graph_state_vector)
kripke_graph_state_vector.reserve = new_instancemethod(_impl.kripke_graph_state_vector_reserve, None, kripke_graph_state_vector)
kripke_graph_state_vector.capacity = new_instancemethod(_impl.kripke_graph_state_vector_capacity, None, kripke_graph_state_vector)
kripke_graph_state_vector_swigregister = _impl.kripke_graph_state_vector_swigregister
kripke_graph_state_vector_swigregister(kripke_graph_state_vector)

class parse_aut_error_list(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _impl.parse_aut_error_list_swiginit(self, _impl.new_parse_aut_error_list())
    __swig_destroy__ = _impl.delete_parse_aut_error_list
parse_aut_error_list.__nonzero__ = new_instancemethod(_impl.parse_aut_error_list___nonzero__, None, parse_aut_error_list)
parse_aut_error_list.__bool__ = new_instancemethod(_impl.parse_aut_error_list___bool__, None, parse_aut_error_list)
parse_aut_error_list_swigregister = _impl.parse_aut_error_list_swigregister
parse_aut_error_list_swigregister(parse_aut_error_list)

parsed_aut_type_HOA = _impl.parsed_aut_type_HOA
parsed_aut_type_NeverClaim = _impl.parsed_aut_type_NeverClaim
parsed_aut_type_LBTT = _impl.parsed_aut_type_LBTT
parsed_aut_type_DRA = _impl.parsed_aut_type_DRA
parsed_aut_type_DSA = _impl.parsed_aut_type_DSA
parsed_aut_type_Unknown = _impl.parsed_aut_type_Unknown
class parsed_aut(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    aut = _swig_property(_impl.parsed_aut_aut_get, _impl.parsed_aut_aut_set)
    ks = _swig_property(_impl.parsed_aut_ks_get, _impl.parsed_aut_ks_set)
    aborted = _swig_property(_impl.parsed_aut_aborted_get, _impl.parsed_aut_aborted_set)
    loc = _swig_property(_impl.parsed_aut_loc_get, _impl.parsed_aut_loc_set)
    type = _swig_property(_impl.parsed_aut_type_get, _impl.parsed_aut_type_set)
    filename = _swig_property(_impl.parsed_aut_filename_get)
    errors = _swig_property(_impl.parsed_aut_errors_get, _impl.parsed_aut_errors_set)

    def __init__(self, str: 'std::string const &'):
        _impl.parsed_aut_swiginit(self, _impl.new_parsed_aut(str))
    __swig_destroy__ = _impl.delete_parsed_aut
parsed_aut.format_errors = new_instancemethod(_impl.parsed_aut_format_errors, None, parsed_aut)
parsed_aut_swigregister = _impl.parsed_aut_swigregister
parsed_aut_swigregister(parsed_aut)

class automaton_parser_options(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ignore_abort = _swig_property(_impl.automaton_parser_options_ignore_abort_get, _impl.automaton_parser_options_ignore_abort_set)
    debug = _swig_property(_impl.automaton_parser_options_debug_get, _impl.automaton_parser_options_debug_set)
    trust_hoa = _swig_property(_impl.automaton_parser_options_trust_hoa_get, _impl.automaton_parser_options_trust_hoa_set)
    raise_errors = _swig_property(_impl.automaton_parser_options_raise_errors_get, _impl.automaton_parser_options_raise_errors_set)
    want_kripke = _swig_property(_impl.automaton_parser_options_want_kripke_get, _impl.automaton_parser_options_want_kripke_set)

    def __init__(self):
        _impl.automaton_parser_options_swiginit(self, _impl.new_automaton_parser_options())
    __swig_destroy__ = _impl.delete_automaton_parser_options
automaton_parser_options_swigregister = _impl.automaton_parser_options_swigregister
automaton_parser_options_swigregister(automaton_parser_options)

class automaton_stream_parser(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _impl.automaton_stream_parser_swiginit(self, _impl.new_automaton_stream_parser(*args))
    __swig_destroy__ = _impl.delete_automaton_stream_parser
automaton_stream_parser.parse = new_instancemethod(_impl.automaton_stream_parser_parse, None, automaton_stream_parser)
automaton_stream_parser_swigregister = _impl.automaton_stream_parser_swigregister
automaton_stream_parser_swigregister(automaton_stream_parser)


def parse_aut(*args) -> "spot::parsed_aut_ptr":
    return _impl.parse_aut(*args)
parse_aut = _impl.parse_aut
class ta(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _impl.delete_ta
ta.get_initial_states_set = new_instancemethod(_impl.ta_get_initial_states_set, None, ta)
ta.get_artificial_initial_state = new_instancemethod(_impl.ta_get_artificial_initial_state, None, ta)
ta.succ_iter = new_instancemethod(_impl.ta_succ_iter, None, ta)
ta.get_dict = new_instancemethod(_impl.ta_get_dict, None, ta)
ta.format_state = new_instancemethod(_impl.ta_format_state, None, ta)
ta.is_accepting_state = new_instancemethod(_impl.ta_is_accepting_state, None, ta)
ta.is_livelock_accepting_state = new_instancemethod(_impl.ta_is_livelock_accepting_state, None, ta)
ta.is_initial_state = new_instancemethod(_impl.ta_is_initial_state, None, ta)
ta.get_state_condition = new_instancemethod(_impl.ta_get_state_condition, None, ta)
ta.free_state = new_instancemethod(_impl.ta_free_state, None, ta)
ta.acc = new_instancemethod(_impl.ta_acc, None, ta)
ta_swigregister = _impl.ta_swigregister
ta_swigregister(ta)

class ta_succ_iterator(twa_succ_iterator):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _impl.delete_ta_succ_iterator
ta_succ_iterator_swigregister = _impl.ta_succ_iterator_swigregister
ta_succ_iterator_swigregister(ta_succ_iterator)

class tgta(twa):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _impl.delete_tgta
tgta.succ_iter_by_changeset = new_instancemethod(_impl.tgta_succ_iter_by_changeset, None, tgta)
tgta_swigregister = _impl.tgta_swigregister
tgta_swigregister(tgta)

class ta_explicit(ta):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, tgba: 'spot::const_twa_ptr const &', n_acc: 'unsigned int', artificial_initial_state: 'state_ta_explicit'=None):
        _impl.ta_explicit_swiginit(self, _impl.new_ta_explicit(tgba, n_acc, artificial_initial_state))
    __swig_destroy__ = _impl.delete_ta_explicit
ta_explicit.get_tgba = new_instancemethod(_impl.ta_explicit_get_tgba, None, ta_explicit)
ta_explicit.add_state = new_instancemethod(_impl.ta_explicit_add_state, None, ta_explicit)
ta_explicit.add_to_initial_states_set = new_instancemethod(_impl.ta_explicit_add_to_initial_states_set, None, ta_explicit)
ta_explicit.create_transition = new_instancemethod(_impl.ta_explicit_create_transition, None, ta_explicit)
ta_explicit.delete_stuttering_transitions = new_instancemethod(_impl.ta_explicit_delete_stuttering_transitions, None, ta_explicit)
ta_explicit.succ_iter = new_instancemethod(_impl.ta_explicit_succ_iter, None, ta_explicit)
ta_explicit.get_dict = new_instancemethod(_impl.ta_explicit_get_dict, None, ta_explicit)
ta_explicit.get_artificial_initial_state = new_instancemethod(_impl.ta_explicit_get_artificial_initial_state, None, ta_explicit)
ta_explicit.set_artificial_initial_state = new_instancemethod(_impl.ta_explicit_set_artificial_initial_state, None, ta_explicit)
ta_explicit.delete_stuttering_and_hole_successors = new_instancemethod(_impl.ta_explicit_delete_stuttering_and_hole_successors, None, ta_explicit)
ta_explicit.get_states_set = new_instancemethod(_impl.ta_explicit_get_states_set, None, ta_explicit)
ta_explicit_swigregister = _impl.ta_explicit_swigregister
ta_explicit_swigregister(ta_explicit)

class state_ta_explicit(state):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _impl.delete_state_ta_explicit
state_ta_explicit_swigregister = _impl.state_ta_explicit_swigregister
state_ta_explicit_swigregister(state_ta_explicit)

class ta_explicit_succ_iterator(ta_succ_iterator):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        _impl.ta_explicit_succ_iterator_swiginit(self, _impl.new_ta_explicit_succ_iterator(*args))
    __swig_destroy__ = _impl.delete_ta_explicit_succ_iterator
ta_explicit_succ_iterator_swigregister = _impl.ta_explicit_succ_iterator_swigregister
ta_explicit_succ_iterator_swigregister(ta_explicit_succ_iterator)


def make_ta_explicit(tgba: 'spot::const_twa_ptr const &', n_acc: 'unsigned int', artificial_initial_state: 'state_ta_explicit'=None) -> "spot::ta_explicit_ptr":
    return _impl.make_ta_explicit(tgba, n_acc, artificial_initial_state)
make_ta_explicit = _impl.make_ta_explicit
class tgta_explicit(tgta):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, tgba: 'spot::const_twa_ptr const &', n_acc: 'unsigned int', artificial_initial_state: 'state_ta_explicit'):
        _impl.tgta_explicit_swiginit(self, _impl.new_tgta_explicit(tgba, n_acc, artificial_initial_state))
    __swig_destroy__ = _impl.delete_tgta_explicit
tgta_explicit.get_init_state = new_instancemethod(_impl.tgta_explicit_get_init_state, None, tgta_explicit)
tgta_explicit.get_ta = new_instancemethod(_impl.tgta_explicit_get_ta, None, tgta_explicit)
tgta_explicit_swigregister = _impl.tgta_explicit_swigregister
tgta_explicit_swigregister(tgta_explicit)


def make_tgta_explicit(tgba: 'spot::const_twa_ptr const &', n_acc: 'unsigned int', artificial_initial_state: 'state_ta_explicit'=None) -> "spot::tgta_explicit_ptr":
    return _impl.make_tgta_explicit(tgba, n_acc, artificial_initial_state)
make_tgta_explicit = _impl.make_tgta_explicit

def tgba_to_ta(tgba_to_convert: 'spot::const_twa_ptr const &', atomic_propositions_set: 'bdd', degeneralized: 'bool'=True, artificial_initial_state_mode: 'bool'=True, single_pass_emptiness_check: 'bool'=False, artificial_livelock_state_mode: 'bool'=False, no_livelock: 'bool'=False) -> "spot::ta_explicit_ptr":
    return _impl.tgba_to_ta(tgba_to_convert, atomic_propositions_set, degeneralized, artificial_initial_state_mode, single_pass_emptiness_check, artificial_livelock_state_mode, no_livelock)
tgba_to_ta = _impl.tgba_to_ta

def tgba_to_tgta(tgba_to_convert: 'spot::const_twa_ptr const &', atomic_propositions_set: 'bdd') -> "spot::tgta_explicit_ptr":
    return _impl.tgba_to_tgta(tgba_to_convert, atomic_propositions_set)
tgba_to_tgta = _impl.tgba_to_tgta

def print_dot(*args) -> "std::ostream &":
    return _impl.print_dot(*args)
print_dot = _impl.print_dot
class ta_statistics(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    edges = _swig_property(_impl.ta_statistics_edges_get, _impl.ta_statistics_edges_set)
    states = _swig_property(_impl.ta_statistics_states_get, _impl.ta_statistics_states_set)
    acceptance_states = _swig_property(_impl.ta_statistics_acceptance_states_get, _impl.ta_statistics_acceptance_states_set)

    def __init__(self):
        _impl.ta_statistics_swiginit(self, _impl.new_ta_statistics())
    __swig_destroy__ = _impl.delete_ta_statistics
ta_statistics.dump = new_instancemethod(_impl.ta_statistics_dump, None, ta_statistics)
ta_statistics_swigregister = _impl.ta_statistics_swigregister
ta_statistics_swigregister(ta_statistics)


def stats_reachable(*args) -> "spot::ta_statistics":
    return _impl.stats_reachable(*args)
stats_reachable = _impl.stats_reachable

def minimize_ta(ta_: 'spot::const_ta_ptr const &') -> "spot::ta_explicit_ptr":
    return _impl.minimize_ta(ta_)
minimize_ta = _impl.minimize_ta

def minimize_tgta(tgta_: 'spot::const_tgta_explicit_ptr const &') -> "spot::tgta_explicit_ptr":
    return _impl.minimize_tgta(tgta_)
minimize_tgta = _impl.minimize_tgta
class ostream(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _impl.delete_ostream
ostream_swigregister = _impl.ostream_swigregister
ostream_swigregister(ostream)

class ofstream(ostream):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, fn: 'char const *'):
        _impl.ofstream_swiginit(self, _impl.new_ofstream(fn))
    __swig_destroy__ = _impl.delete_ofstream
ofstream_swigregister = _impl.ofstream_swigregister
ofstream_swigregister(ofstream)

class ostringstream(ostream):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        _impl.ostringstream_swiginit(self, _impl.new_ostringstream())
    __swig_destroy__ = _impl.delete_ostringstream
ostringstream.str = new_instancemethod(_impl.ostringstream_str, None, ostringstream)
ostringstream_swigregister = _impl.ostringstream_swigregister
ostringstream_swigregister(ostringstream)


def fnode_instances_check() -> "bool":
    return _impl.fnode_instances_check()
fnode_instances_check = _impl.fnode_instances_check

def ensure_digraph(a: 'spot::twa_ptr const &') -> "spot::twa_graph_ptr":
    return _impl.ensure_digraph(a)
ensure_digraph = _impl.ensure_digraph

def get_cout() -> "std::ostream &":
    return _impl.get_cout()
get_cout = _impl.get_cout

def nl_cout() -> "void":
    return _impl.nl_cout()
nl_cout = _impl.nl_cout

def get_cerr() -> "std::ostream &":
    return _impl.get_cerr()
get_cerr = _impl.get_cerr

def nl_cerr() -> "void":
    return _impl.nl_cerr()
nl_cerr = _impl.nl_cerr

def print_on(on: 'ostream', what: 'std::string const &') -> "void":
    return _impl.print_on(on, what)
print_on = _impl.print_on

def unblock_signal(signum: 'int') -> "int":
    return _impl.unblock_signal(signum)
unblock_signal = _impl.unblock_signal

def states_and(aut: 'spot::twa_graph_ptr const &', il: 'vectorunsigned') -> "unsigned int":
    return _impl.states_and(aut, il)
states_and = _impl.states_and


