# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.2
#
# 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
if 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
        if fp is not None:
            try:
                _mod = imp.load_module('_impl', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _impl = swig_import_helper()
    del swig_import_helper
else:
    import _impl
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
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):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


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 value(self) -> "PyObject *" : return _impl.SwigPyIterator_value(self)
    def incr(self, n : 'size_t'=1) -> "swig::SwigPyIterator *" : return _impl.SwigPyIterator_incr(self, n)
    def decr(self, n : 'size_t'=1) -> "swig::SwigPyIterator *" : return _impl.SwigPyIterator_decr(self, n)
    def distance(self, *args) -> "ptrdiff_t" : return _impl.SwigPyIterator_distance(self, *args)
    def equal(self, *args) -> "bool" : return _impl.SwigPyIterator_equal(self, *args)
    def copy(self) -> "swig::SwigPyIterator *" : return _impl.SwigPyIterator_copy(self)
    def next(self) -> "PyObject *" : return _impl.SwigPyIterator_next(self)
    def __next__(self) -> "PyObject *" : return _impl.SwigPyIterator___next__(self)
    def previous(self) -> "PyObject *" : return _impl.SwigPyIterator_previous(self)
    def advance(self, *args) -> "swig::SwigPyIterator *" : return _impl.SwigPyIterator_advance(self, *args)
    def __eq__(self, *args) -> "bool" : return _impl.SwigPyIterator___eq__(self, *args)
    def __ne__(self, *args) -> "bool" : return _impl.SwigPyIterator___ne__(self, *args)
    def __iadd__(self, *args) -> "swig::SwigPyIterator &" : return _impl.SwigPyIterator___iadd__(self, *args)
    def __isub__(self, *args) -> "swig::SwigPyIterator &" : return _impl.SwigPyIterator___isub__(self, *args)
    def __add__(self, *args) -> "swig::SwigPyIterator *" : return _impl.SwigPyIterator___add__(self, *args)
    def __sub__(self, *args) -> "ptrdiff_t" : return _impl.SwigPyIterator___sub__(self, *args)
    def __iter__(self): return self
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, *args): 
        _impl.parse_error_swiginit(self,_impl.new_parse_error(*args))
    __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))
    def next(self) -> "bdd" : return _impl.minato_isop_next(self)
    __swig_destroy__ = _impl.delete_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 parse_options(self, *args) -> "char const *" : return _impl.option_map_parse_options(self, *args)
    def get(self, *args) -> "int" : return _impl.option_map_get(self, *args)
    def get_str(self, *args) -> "std::string" : return _impl.option_map_get_str(self, *args)
    def set_str(self, *args) -> "std::string" : return _impl.option_map_set_str(self, *args)
    def report_unused_options(self) -> "void" : return _impl.option_map_report_unused_options(self)
    def set(self, *args) -> "void" : return _impl.option_map_set(self, *args)
    def __init__(self): 
        _impl.option_map_swiginit(self,_impl.new_option_map())
    __swig_destroy__ = _impl.delete_option_map
option_map_swigregister = _impl.option_map_swigregister
option_map_swigregister(option_map)


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

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

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

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

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

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

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

def escape_rfc4180(*args) -> "std::ostream &" :
  return _impl.escape_rfc4180(*args)
escape_rfc4180 = _impl.escape_rfc4180

def escape_latex(*args) -> "std::ostream &" :
  return _impl.escape_latex(*args)
escape_latex = _impl.escape_latex

def escape_html(*args) -> "std::ostream &" :
  return _impl.escape_html(*args)
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(*args) -> "std::ostream &" :
  return _impl.quote_shell_string(*args)
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 is_known(self) -> "bool" : return _impl.trival_is_known(self)
    def is_maybe(self) -> "bool" : return _impl.trival_is_maybe(self)
    def is_true(self) -> "bool" : return _impl.trival_is_true(self)
    def is_false(self) -> "bool" : return _impl.trival_is_false(self)
    def __eq__(self, *args) -> "bool" : return _impl.trival___eq__(self, *args)
    def __ne__(self, *args) -> "bool" : return _impl.trival___ne__(self, *args)
    def val(self) -> "spot::trival::value_t" : return _impl.trival_val(self)
    def __nonzero__(self):
        return _impl.trival___nonzero__(self)
    __bool__ = __nonzero__


    def __repr__(self) -> "std::string" : return _impl.trival___repr__(self)
    def __str__(self) -> "std::string" : return _impl.trival___str__(self)
    def __neg__(self) -> "spot::trival" : return _impl.trival___neg__(self)
    def __and__(self, *args) -> "spot::trival" : return _impl.trival___and__(self, *args)
    def __or__(self, *args) -> "spot::trival" : return _impl.trival___or__(self, *args)
    __swig_destroy__ = _impl.delete_trival
trival_swigregister = _impl.trival_swigregister
trival_swigregister(trival)

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


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

def __ne__(*args) -> "bool" :
  return _impl.__ne__(*args)
__ne__ = _impl.__ne__
ff = _impl.ff
tt = _impl.tt
eword = _impl.eword
ap = _impl.ap
Not = _impl.Not
X = _impl.X
F = _impl.F
G = _impl.G
Closure = _impl.Closure
NegClosure = _impl.NegClosure
NegClosureMarked = _impl.NegClosureMarked
Xor = _impl.Xor
Implies = _impl.Implies
Equiv = _impl.Equiv
U = _impl.U
R = _impl.R
W = _impl.W
M = _impl.M
EConcat = _impl.EConcat
EConcatMarked = _impl.EConcatMarked
UConcat = _impl.UConcat
Or = _impl.Or
OrRat = _impl.OrRat
And = _impl.And
AndRat = _impl.AndRat
AndNLM = _impl.AndNLM
Concat = _impl.Concat
Fusion = _impl.Fusion
Star = _impl.Star
FStar = _impl.FStar
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 __lt__(self, *args) -> "bool" : return _impl.formula___lt__(self, *args)
    def __le__(self, *args) -> "bool" : return _impl.formula___le__(self, *args)
    def __gt__(self, *args) -> "bool" : return _impl.formula___gt__(self, *args)
    def __ge__(self, *args) -> "bool" : return _impl.formula___ge__(self, *args)
    def __eq__(self, *args) -> "bool" : return _impl.formula___eq__(self, *args)
    def __ne__(self, *args) -> "bool" : return _impl.formula___ne__(self, *args)
    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)
    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)
    sugar_goto = staticmethod(_impl.formula_sugar_goto)
    sugar_equal = staticmethod(_impl.formula_sugar_equal)
    def kind(self) -> "spot::op" : return _impl.formula_kind(self)
    def kindstr(self) -> "std::string" : return _impl.formula_kindstr(self)
    def _is(self, *args) -> "bool" : return _impl.formula__is(self, *args)
    def get_child_of(self, *args) -> "spot::formula" : return _impl.formula_get_child_of(self, *args)
    def min(self) -> "unsigned int" : return _impl.formula_min(self)
    def max(self) -> "unsigned int" : return _impl.formula_max(self)
    def size(self) -> "unsigned int" : return _impl.formula_size(self)
    def id(self) -> "size_t" : return _impl.formula_id(self)
    ff = staticmethod(_impl.formula_ff)
    def is_ff(self) -> "bool" : return _impl.formula_is_ff(self)
    tt = staticmethod(_impl.formula_tt)
    def is_tt(self) -> "bool" : return _impl.formula_is_tt(self)
    eword = staticmethod(_impl.formula_eword)
    def is_eword(self) -> "bool" : return _impl.formula_is_eword(self)
    def is_constant(self) -> "bool" : return _impl.formula_is_constant(self)
    def is_Kleene_star(self) -> "bool" : return _impl.formula_is_Kleene_star(self)
    one_star = staticmethod(_impl.formula_one_star)
    def is_literal(self) -> "bool" : return _impl.formula_is_literal(self)
    def ap_name(self) -> "std::string const &" : return _impl.formula_ap_name(self)
    def dump(self, *args) -> "std::ostream &" : return _impl.formula_dump(self, *args)
    def all_but(self, *args) -> "spot::formula" : return _impl.formula_all_but(self, *args)
    def boolean_count(self) -> "unsigned int" : return _impl.formula_boolean_count(self)
    def boolean_operands(self, width : 'unsigned int *'=None) -> "spot::formula" : return _impl.formula_boolean_operands(self, width)
    def is_boolean(self) -> "bool" : return _impl.formula_is_boolean(self)
    def is_sugar_free_boolean(self) -> "bool" : return _impl.formula_is_sugar_free_boolean(self)
    def is_in_nenoform(self) -> "bool" : return _impl.formula_is_in_nenoform(self)
    def is_syntactic_stutter_invariant(self) -> "bool" : return _impl.formula_is_syntactic_stutter_invariant(self)
    def is_sugar_free_ltl(self) -> "bool" : return _impl.formula_is_sugar_free_ltl(self)
    def is_ltl_formula(self) -> "bool" : return _impl.formula_is_ltl_formula(self)
    def is_psl_formula(self) -> "bool" : return _impl.formula_is_psl_formula(self)
    def is_sere_formula(self) -> "bool" : return _impl.formula_is_sere_formula(self)
    def is_finite(self) -> "bool" : return _impl.formula_is_finite(self)
    def is_eventual(self) -> "bool" : return _impl.formula_is_eventual(self)
    def is_universal(self) -> "bool" : return _impl.formula_is_universal(self)
    def is_syntactic_safety(self) -> "bool" : return _impl.formula_is_syntactic_safety(self)
    def is_syntactic_guarantee(self) -> "bool" : return _impl.formula_is_syntactic_guarantee(self)
    def is_syntactic_obligation(self) -> "bool" : return _impl.formula_is_syntactic_obligation(self)
    def is_syntactic_recurrence(self) -> "bool" : return _impl.formula_is_syntactic_recurrence(self)
    def is_syntactic_persistence(self) -> "bool" : return _impl.formula_is_syntactic_persistence(self)
    def is_marked(self) -> "bool" : return _impl.formula_is_marked(self)
    def accepts_eword(self) -> "bool" : return _impl.formula_accepts_eword(self)
    def has_lbt_atomic_props(self) -> "bool" : return _impl.formula_has_lbt_atomic_props(self)
    def has_spin_atomic_props(self) -> "bool" : return _impl.formula_has_spin_atomic_props(self)
    def __cmp__(self, *args) -> "int" : return _impl.formula___cmp__(self, *args)
    def __hash__(self) -> "size_t" : return _impl.formula___hash__(self)
    def __len__(self) -> "unsigned int" : return _impl.formula___len__(self)
    def __getitem__(self, *args) -> "spot::formula" : return _impl.formula___getitem__(self, *args)
    def __repr__(self) -> "std::string" : return _impl.formula___repr__(self)
    def _repr_latex_(self) -> "std::string" : return _impl.formula__repr_latex_(self)
    def __str__(self) -> "std::string" : return _impl.formula___str__(self)
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(*args) -> "spot::formula" :
  return _impl.formula_unop(*args)
formula_unop = _impl.formula_unop

def formula_Not(*args) -> "spot::formula" :
  return _impl.formula_Not(*args)
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(*args) -> "spot::formula" :
  return _impl.formula_Closure(*args)
formula_Closure = _impl.formula_Closure

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def formula_Fusion(*args) -> "spot::formula" :
  return _impl.formula_Fusion(*args)
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_sugar_goto(*args) -> "spot::formula" :
  return _impl.formula_sugar_goto(*args)
formula_sugar_goto = _impl.formula_sugar_goto

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

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(*args) -> "std::ostream &" :
  return _impl.print_formula_props(*args)
print_formula_props = _impl.print_formula_props

def list_formula_props(*args) -> "std::list< std::string,std::allocator< std::string > >" :
  return _impl.list_formula_props(*args)
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 iterator(self) -> "swig::SwigPyIterator *" : return _impl.liststr_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self) -> "bool" : return _impl.liststr___nonzero__(self)
    def __bool__(self) -> "bool" : return _impl.liststr___bool__(self)
    def __len__(self) -> "std::list< std::string >::size_type" : return _impl.liststr___len__(self)
    def pop(self) -> "std::list< std::string >::value_type" : return _impl.liststr_pop(self)
    def __getslice__(self, *args) -> "std::list< std::string,std::allocator< std::string > > *" : return _impl.liststr___getslice__(self, *args)
    def __setslice__(self, *args) -> "void" : return _impl.liststr___setslice__(self, *args)
    def __delslice__(self, *args) -> "void" : return _impl.liststr___delslice__(self, *args)
    def __delitem__(self, *args) -> "void" : return _impl.liststr___delitem__(self, *args)
    def __getitem__(self, *args) -> "std::list< std::string >::value_type const &" : return _impl.liststr___getitem__(self, *args)
    def __setitem__(self, *args) -> "void" : return _impl.liststr___setitem__(self, *args)
    def append(self, *args) -> "void" : return _impl.liststr_append(self, *args)
    def empty(self) -> "bool" : return _impl.liststr_empty(self)
    def size(self) -> "std::list< std::string >::size_type" : return _impl.liststr_size(self)
    def clear(self) -> "void" : return _impl.liststr_clear(self)
    def swap(self, *args) -> "void" : return _impl.liststr_swap(self, *args)
    def get_allocator(self) -> "std::list< std::string >::allocator_type" : return _impl.liststr_get_allocator(self)
    def begin(self) -> "std::list< std::string >::iterator" : return _impl.liststr_begin(self)
    def end(self) -> "std::list< std::string >::iterator" : return _impl.liststr_end(self)
    def rbegin(self) -> "std::list< std::string >::reverse_iterator" : return _impl.liststr_rbegin(self)
    def rend(self) -> "std::list< std::string >::reverse_iterator" : return _impl.liststr_rend(self)
    def pop_back(self) -> "void" : return _impl.liststr_pop_back(self)
    def erase(self, *args) -> "std::list< std::string >::iterator" : return _impl.liststr_erase(self, *args)
    def __init__(self, *args): 
        _impl.liststr_swiginit(self,_impl.new_liststr(*args))
    def push_back(self, *args) -> "void" : return _impl.liststr_push_back(self, *args)
    def front(self) -> "std::list< std::string >::value_type const &" : return _impl.liststr_front(self)
    def back(self) -> "std::list< std::string >::value_type const &" : return _impl.liststr_back(self)
    def assign(self, *args) -> "void" : return _impl.liststr_assign(self, *args)
    def resize(self, *args) -> "void" : return _impl.liststr_resize(self, *args)
    def insert(self, *args) -> "void" : return _impl.liststr_insert(self, *args)
    def pop_front(self) -> "void" : return _impl.liststr_pop_front(self)
    def push_front(self, *args) -> "void" : return _impl.liststr_push_front(self, *args)
    def reverse(self) -> "void" : return _impl.liststr_reverse(self)
    __swig_destroy__ = _impl.delete_liststr
liststr_swigregister = _impl.liststr_swigregister
liststr_swigregister(liststr)

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 iterator(self) -> "swig::SwigPyIterator *" : return _impl.vectorformula_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self) -> "bool" : return _impl.vectorformula___nonzero__(self)
    def __bool__(self) -> "bool" : return _impl.vectorformula___bool__(self)
    def __len__(self) -> "std::vector< spot::formula >::size_type" : return _impl.vectorformula___len__(self)
    def pop(self) -> "std::vector< spot::formula >::value_type" : return _impl.vectorformula_pop(self)
    def __getslice__(self, *args) -> "std::vector< spot::formula,std::allocator< spot::formula > > *" : return _impl.vectorformula___getslice__(self, *args)
    def __setslice__(self, *args) -> "void" : return _impl.vectorformula___setslice__(self, *args)
    def __delslice__(self, *args) -> "void" : return _impl.vectorformula___delslice__(self, *args)
    def __delitem__(self, *args) -> "void" : return _impl.vectorformula___delitem__(self, *args)
    def __getitem__(self, *args) -> "std::vector< spot::formula >::value_type const &" : return _impl.vectorformula___getitem__(self, *args)
    def __setitem__(self, *args) -> "void" : return _impl.vectorformula___setitem__(self, *args)
    def append(self, *args) -> "void" : return _impl.vectorformula_append(self, *args)
    def empty(self) -> "bool" : return _impl.vectorformula_empty(self)
    def size(self) -> "std::vector< spot::formula >::size_type" : return _impl.vectorformula_size(self)
    def clear(self) -> "void" : return _impl.vectorformula_clear(self)
    def swap(self, *args) -> "void" : return _impl.vectorformula_swap(self, *args)
    def get_allocator(self) -> "std::vector< spot::formula >::allocator_type" : return _impl.vectorformula_get_allocator(self)
    def begin(self) -> "std::vector< spot::formula >::iterator" : return _impl.vectorformula_begin(self)
    def end(self) -> "std::vector< spot::formula >::iterator" : return _impl.vectorformula_end(self)
    def rbegin(self) -> "std::vector< spot::formula >::reverse_iterator" : return _impl.vectorformula_rbegin(self)
    def rend(self) -> "std::vector< spot::formula >::reverse_iterator" : return _impl.vectorformula_rend(self)
    def pop_back(self) -> "void" : return _impl.vectorformula_pop_back(self)
    def erase(self, *args) -> "std::vector< spot::formula >::iterator" : return _impl.vectorformula_erase(self, *args)
    def __init__(self, *args): 
        _impl.vectorformula_swiginit(self,_impl.new_vectorformula(*args))
    def push_back(self, *args) -> "void" : return _impl.vectorformula_push_back(self, *args)
    def front(self) -> "std::vector< spot::formula >::value_type const &" : return _impl.vectorformula_front(self)
    def back(self) -> "std::vector< spot::formula >::value_type const &" : return _impl.vectorformula_back(self)
    def assign(self, *args) -> "void" : return _impl.vectorformula_assign(self, *args)
    def resize(self, *args) -> "void" : return _impl.vectorformula_resize(self, *args)
    def insert(self, *args) -> "void" : return _impl.vectorformula_insert(self, *args)
    def reserve(self, *args) -> "void" : return _impl.vectorformula_reserve(self, *args)
    def capacity(self) -> "std::vector< spot::formula >::size_type" : return _impl.vectorformula_capacity(self)
    __swig_destroy__ = _impl.delete_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 iterator(self) -> "swig::SwigPyIterator *" : return _impl.vectorunsigned_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self) -> "bool" : return _impl.vectorunsigned___nonzero__(self)
    def __bool__(self) -> "bool" : return _impl.vectorunsigned___bool__(self)
    def __len__(self) -> "std::vector< unsigned int >::size_type" : return _impl.vectorunsigned___len__(self)
    def pop(self) -> "std::vector< unsigned int >::value_type" : return _impl.vectorunsigned_pop(self)
    def __getslice__(self, *args) -> "std::vector< unsigned int,std::allocator< unsigned int > > *" : return _impl.vectorunsigned___getslice__(self, *args)
    def __setslice__(self, *args) -> "void" : return _impl.vectorunsigned___setslice__(self, *args)
    def __delslice__(self, *args) -> "void" : return _impl.vectorunsigned___delslice__(self, *args)
    def __delitem__(self, *args) -> "void" : return _impl.vectorunsigned___delitem__(self, *args)
    def __getitem__(self, *args) -> "std::vector< unsigned int >::value_type const &" : return _impl.vectorunsigned___getitem__(self, *args)
    def __setitem__(self, *args) -> "void" : return _impl.vectorunsigned___setitem__(self, *args)
    def append(self, *args) -> "void" : return _impl.vectorunsigned_append(self, *args)
    def empty(self) -> "bool" : return _impl.vectorunsigned_empty(self)
    def size(self) -> "std::vector< unsigned int >::size_type" : return _impl.vectorunsigned_size(self)
    def clear(self) -> "void" : return _impl.vectorunsigned_clear(self)
    def swap(self, *args) -> "void" : return _impl.vectorunsigned_swap(self, *args)
    def get_allocator(self) -> "std::vector< unsigned int >::allocator_type" : return _impl.vectorunsigned_get_allocator(self)
    def begin(self) -> "std::vector< unsigned int >::iterator" : return _impl.vectorunsigned_begin(self)
    def end(self) -> "std::vector< unsigned int >::iterator" : return _impl.vectorunsigned_end(self)
    def rbegin(self) -> "std::vector< unsigned int >::reverse_iterator" : return _impl.vectorunsigned_rbegin(self)
    def rend(self) -> "std::vector< unsigned int >::reverse_iterator" : return _impl.vectorunsigned_rend(self)
    def pop_back(self) -> "void" : return _impl.vectorunsigned_pop_back(self)
    def erase(self, *args) -> "std::vector< unsigned int >::iterator" : return _impl.vectorunsigned_erase(self, *args)
    def __init__(self, *args): 
        _impl.vectorunsigned_swiginit(self,_impl.new_vectorunsigned(*args))
    def push_back(self, *args) -> "void" : return _impl.vectorunsigned_push_back(self, *args)
    def front(self) -> "std::vector< unsigned int >::value_type const &" : return _impl.vectorunsigned_front(self)
    def back(self) -> "std::vector< unsigned int >::value_type const &" : return _impl.vectorunsigned_back(self)
    def assign(self, *args) -> "void" : return _impl.vectorunsigned_assign(self, *args)
    def resize(self, *args) -> "void" : return _impl.vectorunsigned_resize(self, *args)
    def insert(self, *args) -> "void" : return _impl.vectorunsigned_insert(self, *args)
    def reserve(self, *args) -> "void" : return _impl.vectorunsigned_reserve(self, *args)
    def capacity(self) -> "std::vector< unsigned int >::size_type" : return _impl.vectorunsigned_capacity(self)
    __swig_destroy__ = _impl.delete_vectorunsigned
vectorunsigned_swigregister = _impl.vectorunsigned_swigregister
vectorunsigned_swigregister(vectorunsigned)

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 iterator(self) -> "swig::SwigPyIterator *" : return _impl.vectorstring_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self) -> "bool" : return _impl.vectorstring___nonzero__(self)
    def __bool__(self) -> "bool" : return _impl.vectorstring___bool__(self)
    def __len__(self) -> "std::vector< std::string >::size_type" : return _impl.vectorstring___len__(self)
    def pop(self) -> "std::vector< std::string >::value_type" : return _impl.vectorstring_pop(self)
    def __getslice__(self, *args) -> "std::vector< std::string,std::allocator< std::string > > *" : return _impl.vectorstring___getslice__(self, *args)
    def __setslice__(self, *args) -> "void" : return _impl.vectorstring___setslice__(self, *args)
    def __delslice__(self, *args) -> "void" : return _impl.vectorstring___delslice__(self, *args)
    def __delitem__(self, *args) -> "void" : return _impl.vectorstring___delitem__(self, *args)
    def __getitem__(self, *args) -> "std::vector< std::string >::value_type const &" : return _impl.vectorstring___getitem__(self, *args)
    def __setitem__(self, *args) -> "void" : return _impl.vectorstring___setitem__(self, *args)
    def append(self, *args) -> "void" : return _impl.vectorstring_append(self, *args)
    def empty(self) -> "bool" : return _impl.vectorstring_empty(self)
    def size(self) -> "std::vector< std::string >::size_type" : return _impl.vectorstring_size(self)
    def clear(self) -> "void" : return _impl.vectorstring_clear(self)
    def swap(self, *args) -> "void" : return _impl.vectorstring_swap(self, *args)
    def get_allocator(self) -> "std::vector< std::string >::allocator_type" : return _impl.vectorstring_get_allocator(self)
    def begin(self) -> "std::vector< std::string >::iterator" : return _impl.vectorstring_begin(self)
    def end(self) -> "std::vector< std::string >::iterator" : return _impl.vectorstring_end(self)
    def rbegin(self) -> "std::vector< std::string >::reverse_iterator" : return _impl.vectorstring_rbegin(self)
    def rend(self) -> "std::vector< std::string >::reverse_iterator" : return _impl.vectorstring_rend(self)
    def pop_back(self) -> "void" : return _impl.vectorstring_pop_back(self)
    def erase(self, *args) -> "std::vector< std::string >::iterator" : return _impl.vectorstring_erase(self, *args)
    def __init__(self, *args): 
        _impl.vectorstring_swiginit(self,_impl.new_vectorstring(*args))
    def push_back(self, *args) -> "void" : return _impl.vectorstring_push_back(self, *args)
    def front(self) -> "std::vector< std::string >::value_type const &" : return _impl.vectorstring_front(self)
    def back(self) -> "std::vector< std::string >::value_type const &" : return _impl.vectorstring_back(self)
    def assign(self, *args) -> "void" : return _impl.vectorstring_assign(self, *args)
    def resize(self, *args) -> "void" : return _impl.vectorstring_resize(self, *args)
    def insert(self, *args) -> "void" : return _impl.vectorstring_insert(self, *args)
    def reserve(self, *args) -> "void" : return _impl.vectorstring_reserve(self, *args)
    def capacity(self) -> "std::vector< std::string >::size_type" : return _impl.vectorstring_capacity(self)
    __swig_destroy__ = _impl.delete_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 iterator(self) -> "swig::SwigPyIterator *" : return _impl.atomic_prop_set_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self) -> "bool" : return _impl.atomic_prop_set___nonzero__(self)
    def __bool__(self) -> "bool" : return _impl.atomic_prop_set___bool__(self)
    def __len__(self) -> "std::set< spot::formula >::size_type" : return _impl.atomic_prop_set___len__(self)
    def append(self, *args) -> "void" : return _impl.atomic_prop_set_append(self, *args)
    def __contains__(self, *args) -> "bool" : return _impl.atomic_prop_set___contains__(self, *args)
    def __getitem__(self, *args) -> "std::set< spot::formula >::value_type" : return _impl.atomic_prop_set___getitem__(self, *args)
    def add(self, *args) -> "void" : return _impl.atomic_prop_set_add(self, *args)
    def discard(self, *args) -> "void" : return _impl.atomic_prop_set_discard(self, *args)
    def __init__(self, *args): 
        _impl.atomic_prop_set_swiginit(self,_impl.new_atomic_prop_set(*args))
    def empty(self) -> "bool" : return _impl.atomic_prop_set_empty(self)
    def size(self) -> "std::set< spot::formula >::size_type" : return _impl.atomic_prop_set_size(self)
    def clear(self) -> "void" : return _impl.atomic_prop_set_clear(self)
    def swap(self, *args) -> "void" : return _impl.atomic_prop_set_swap(self, *args)
    def count(self, *args) -> "std::set< spot::formula >::size_type" : return _impl.atomic_prop_set_count(self, *args)
    def begin(self) -> "std::set< spot::formula >::iterator" : return _impl.atomic_prop_set_begin(self)
    def end(self) -> "std::set< spot::formula >::iterator" : return _impl.atomic_prop_set_end(self)
    def rbegin(self) -> "std::set< spot::formula >::reverse_iterator" : return _impl.atomic_prop_set_rbegin(self)
    def rend(self) -> "std::set< spot::formula >::reverse_iterator" : return _impl.atomic_prop_set_rend(self)
    def erase(self, *args) -> "void" : return _impl.atomic_prop_set_erase(self, *args)
    def find(self, *args) -> "std::set< spot::formula >::iterator" : return _impl.atomic_prop_set_find(self, *args)
    def lower_bound(self, *args) -> "std::set< spot::formula >::iterator" : return _impl.atomic_prop_set_lower_bound(self, *args)
    def upper_bound(self, *args) -> "std::set< spot::formula >::iterator" : return _impl.atomic_prop_set_upper_bound(self, *args)
    def equal_range(self, *args) -> "std::pair< std::set< spot::formula >::iterator,std::set< spot::formula >::iterator >" : return _impl.atomic_prop_set_equal_range(self, *args)
    def insert(self, *args) -> "std::pair< std::set< spot::formula >::iterator,bool >" : return _impl.atomic_prop_set_insert(self, *args)
    def __str__(self) -> "std::string" : return _impl.atomic_prop_set___str__(self)
    def __repr__(self) -> "std::string" : return _impl.atomic_prop_set___repr__(self)
    def _repr_latex_(self) -> "std::string" : return _impl.atomic_prop_set__repr_latex_(self)
    __swig_destroy__ = _impl.delete_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 iterator(self) -> "swig::SwigPyIterator *" : return _impl.relabeling_map_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self) -> "bool" : return _impl.relabeling_map___nonzero__(self)
    def __bool__(self) -> "bool" : return _impl.relabeling_map___bool__(self)
    def __len__(self) -> "std::map< spot::formula,spot::formula >::size_type" : return _impl.relabeling_map___len__(self)
    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 __getitem__(self, *args) -> "std::map< spot::formula,spot::formula >::mapped_type const &" : return _impl.relabeling_map___getitem__(self, *args)
    def __delitem__(self, *args) -> "void" : return _impl.relabeling_map___delitem__(self, *args)
    def has_key(self, *args) -> "bool" : return _impl.relabeling_map_has_key(self, *args)
    def keys(self) -> "PyObject *" : return _impl.relabeling_map_keys(self)
    def values(self) -> "PyObject *" : return _impl.relabeling_map_values(self)
    def items(self) -> "PyObject *" : return _impl.relabeling_map_items(self)
    def __contains__(self, *args) -> "bool" : return _impl.relabeling_map___contains__(self, *args)
    def key_iterator(self) -> "swig::SwigPyIterator *" : return _impl.relabeling_map_key_iterator(self)
    def value_iterator(self) -> "swig::SwigPyIterator *" : return _impl.relabeling_map_value_iterator(self)
    def __setitem__(self, *args) -> "void" : return _impl.relabeling_map___setitem__(self, *args)
    def asdict(self) -> "PyObject *" : return _impl.relabeling_map_asdict(self)
    def __init__(self, *args): 
        _impl.relabeling_map_swiginit(self,_impl.new_relabeling_map(*args))
    def empty(self) -> "bool" : return _impl.relabeling_map_empty(self)
    def size(self) -> "std::map< spot::formula,spot::formula >::size_type" : return _impl.relabeling_map_size(self)
    def clear(self) -> "void" : return _impl.relabeling_map_clear(self)
    def swap(self, *args) -> "void" : return _impl.relabeling_map_swap(self, *args)
    def get_allocator(self) -> "std::map< spot::formula,spot::formula >::allocator_type" : return _impl.relabeling_map_get_allocator(self)
    def begin(self) -> "std::map< spot::formula,spot::formula >::iterator" : return _impl.relabeling_map_begin(self)
    def end(self) -> "std::map< spot::formula,spot::formula >::iterator" : return _impl.relabeling_map_end(self)
    def rbegin(self) -> "std::map< spot::formula,spot::formula >::reverse_iterator" : return _impl.relabeling_map_rbegin(self)
    def rend(self) -> "std::map< spot::formula,spot::formula >::reverse_iterator" : return _impl.relabeling_map_rend(self)
    def count(self, *args) -> "std::map< spot::formula,spot::formula >::size_type" : return _impl.relabeling_map_count(self, *args)
    def erase(self, *args) -> "void" : return _impl.relabeling_map_erase(self, *args)
    def find(self, *args) -> "std::map< spot::formula,spot::formula >::iterator" : return _impl.relabeling_map_find(self, *args)
    def lower_bound(self, *args) -> "std::map< spot::formula,spot::formula >::iterator" : return _impl.relabeling_map_lower_bound(self, *args)
    def upper_bound(self, *args) -> "std::map< spot::formula,spot::formula >::iterator" : return _impl.relabeling_map_upper_bound(self, *args)
    __swig_destroy__ = _impl.delete_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
    def require(self, *args) -> "spot::formula" : return _impl.environment_require(self, *args)
    def name(self) -> "std::string const &" : return _impl.environment_name(self)
    __swig_destroy__ = _impl.delete_environment
environment_swigregister = _impl.environment_swigregister
environment_swigregister(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 __nonzero__(self) -> "bool" : return _impl.parse_error_list___nonzero__(self)
    def __bool__(self) -> "bool" : return _impl.parse_error_list___bool__(self)
    def __init__(self): 
        _impl.parse_error_list_swiginit(self,_impl.new_parse_error_list())
    __swig_destroy__ = _impl.delete_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, str : 'std::string const &'=""): 
        _impl.parsed_formula_swiginit(self,_impl.new_parsed_formula(str))
    def format_errors(self, *args) -> "bool" : return _impl.parsed_formula_format_errors(self, *args)
    __swig_destroy__ = _impl.delete_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(*args) -> "void" :
  return _impl.fix_utf8_locations(*args)
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)
    def register_proposition(self, *args) -> "int" : return _impl.bdd_dict_register_proposition(self, *args)
    def has_registered_proposition(self, *args) -> "int" : return _impl.bdd_dict_has_registered_proposition(self, *args)
    def varnum(self, *args) -> "int" : return _impl.bdd_dict_varnum(self, *args)
    def register_acceptance_variable(self, *args) -> "int" : return _impl.bdd_dict_register_acceptance_variable(self, *args)
    def register_anonymous_variables(self, *args) -> "int" : return _impl.bdd_dict_register_anonymous_variables(self, *args)
    def register_all_variables_of(self, *args) -> "void" : return _impl.bdd_dict_register_all_variables_of(self, *args)
    def register_all_propositions_of(self, *args) -> "void" : return _impl.bdd_dict_register_all_propositions_of(self, *args)
    def unregister_all_my_variables(self, *args) -> "void" : return _impl.bdd_dict_unregister_all_my_variables(self, *args)
    def unregister_variable(self, *args) -> "void" : return _impl.bdd_dict_unregister_variable(self, *args)
    def dump(self, *args) -> "std::ostream &" : return _impl.bdd_dict_dump(self, *args)
    def assert_emptiness(self) -> "void" : return _impl.bdd_dict_assert_emptiness(self)
    def __eq__(self, *args) -> "bool" : return _impl.bdd_dict___eq__(self, *args)
    def __ne__(self, *args) -> "bool" : return _impl.bdd_dict___ne__(self, *args)
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(*args) -> "std::ostream &" :
  return _impl.bdd_print_sat(*args)
bdd_print_sat = _impl.bdd_print_sat

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

def bdd_print_accset(*args) -> "std::ostream &" :
  return _impl.bdd_print_accset(*args)
bdd_print_accset = _impl.bdd_print_accset

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

def bdd_print_set(*args) -> "std::ostream &" :
  return _impl.bdd_print_set(*args)
bdd_print_set = _impl.bdd_print_set

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

def bdd_print_formula(*args) -> "std::ostream &" :
  return _impl.bdd_print_formula(*args)
bdd_print_formula = _impl.bdd_print_formula

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

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

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

def bdd_print_isop(*args) -> "std::ostream &" :
  return _impl.bdd_print_isop(*args)
bdd_print_isop = _impl.bdd_print_isop

def formula_to_bdd(*args) -> "bdd" :
  return _impl.formula_to_bdd(*args)
formula_to_bdd = _impl.formula_to_bdd

def bdd_to_formula(*args) -> "spot::formula" :
  return _impl.bdd_to_formula(*args)
bdd_to_formula = _impl.bdd_to_formula
class acc_cond(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    Inf = _impl.acc_cond_Inf
    Fin = _impl.acc_cond_Fin
    InfNeg = _impl.acc_cond_InfNeg
    FinNeg = _impl.acc_cond_FinNeg
    And = _impl.acc_cond_And
    Or = _impl.acc_cond_Or
    def __init__(self, *args): 
        _impl.acc_cond_swiginit(self,_impl.new_acc_cond(*args))
    __swig_destroy__ = _impl.delete_acc_cond
    def set_acceptance(self, *args) -> "void" : return _impl.acc_cond_set_acceptance(self, *args)
    def get_acceptance(self, *args) -> "spot::acc_cond::acc_code &" : return _impl.acc_cond_get_acceptance(self, *args)
    def uses_fin_acceptance(self) -> "bool" : return _impl.acc_cond_uses_fin_acceptance(self)
    def is_t(self) -> "bool" : return _impl.acc_cond_is_t(self)
    def is_all(self) -> "bool" : return _impl.acc_cond_is_all(self)
    def is_f(self) -> "bool" : return _impl.acc_cond_is_f(self)
    def is_none(self) -> "bool" : return _impl.acc_cond_is_none(self)
    def is_buchi(self) -> "bool" : return _impl.acc_cond_is_buchi(self)
    def is_co_buchi(self) -> "bool" : return _impl.acc_cond_is_co_buchi(self)
    def set_generalized_buchi(self) -> "void" : return _impl.acc_cond_set_generalized_buchi(self)
    def is_generalized_buchi(self) -> "bool" : return _impl.acc_cond_is_generalized_buchi(self)
    def is_generalized_co_buchi(self) -> "bool" : return _impl.acc_cond_is_generalized_co_buchi(self)
    def is_rabin(self) -> "int" : return _impl.acc_cond_is_rabin(self)
    def is_streett(self) -> "int" : return _impl.acc_cond_is_streett(self)
    def is_generalized_rabin(self, *args) -> "bool" : return _impl.acc_cond_is_generalized_rabin(self, *args)
    def is_parity(self, *args) -> "bool" : return _impl.acc_cond_is_parity(self, *args)
    def unsat_mark(self) -> "std::pair< bool,spot::acc_cond::mark_t >" : return _impl.acc_cond_unsat_mark(self)
    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)
    def add_sets(self, *args) -> "unsigned int" : return _impl.acc_cond_add_sets(self, *args)
    def add_set(self) -> "unsigned int" : return _impl.acc_cond_add_set(self)
    def mark(self, *args) -> "spot::acc_cond::mark_t" : return _impl.acc_cond_mark(self, *args)
    def comp(self, *args) -> "spot::acc_cond::mark_t" : return _impl.acc_cond_comp(self, *args)
    def all_sets(self) -> "spot::acc_cond::mark_t" : return _impl.acc_cond_all_sets(self)
    def accepting(self, *args) -> "bool" : return _impl.acc_cond_accepting(self, *args)
    def inf_satisfiable(self, *args) -> "bool" : return _impl.acc_cond_inf_satisfiable(self, *args)
    def accepting_sets(self, *args) -> "spot::acc_cond::mark_t" : return _impl.acc_cond_accepting_sets(self, *args)
    def format(self, *args) -> "std::string" : return _impl.acc_cond_format(self, *args)
    def num_sets(self) -> "unsigned int" : return _impl.acc_cond_num_sets(self)
    def __repr__(self) -> "std::string" : return _impl.acc_cond___repr__(self)
    def __str__(self) -> "std::string" : return _impl.acc_cond___str__(self)
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')
    id = _swig_property(_impl.mark_t_id_get, _impl.mark_t_id_set)
    def __eq__(self, *args) -> "bool" : return _impl.mark_t___eq__(self, *args)
    def __ne__(self, *args) -> "bool" : return _impl.mark_t___ne__(self, *args)
    def __lt__(self, *args) -> "bool" : return _impl.mark_t___lt__(self, *args)
    def __le__(self, *args) -> "bool" : return _impl.mark_t___le__(self, *args)
    def __gt__(self, *args) -> "bool" : return _impl.mark_t___gt__(self, *args)
    def __ge__(self, *args) -> "bool" : return _impl.mark_t___ge__(self, *args)
    def __nonzero__(self):
        return _impl.mark_t___nonzero__(self)
    __bool__ = __nonzero__


    def has(self, *args) -> "bool" : return _impl.mark_t_has(self, *args)
    def set(self, *args) -> "void" : return _impl.mark_t_set(self, *args)
    def clear(self, *args) -> "void" : return _impl.mark_t_clear(self, *args)
    def __iand__(self, *args) -> "spot::acc_cond::mark_t &" : return _impl.mark_t___iand__(self, *args)
    def __ior__(self, *args) -> "spot::acc_cond::mark_t &" : return _impl.mark_t___ior__(self, *args)
    def __isub__(self, *args) -> "spot::acc_cond::mark_t &" : return _impl.mark_t___isub__(self, *args)
    def __ixor__(self, *args) -> "spot::acc_cond::mark_t &" : return _impl.mark_t___ixor__(self, *args)
    def __and__(self, *args) -> "spot::acc_cond::mark_t" : return _impl.mark_t___and__(self, *args)
    def __or__(self, *args) -> "spot::acc_cond::mark_t" : return _impl.mark_t___or__(self, *args)
    def __sub__(self, *args) -> "spot::acc_cond::mark_t" : return _impl.mark_t___sub__(self, *args)
    def __invert__(self) -> "spot::acc_cond::mark_t" : return _impl.mark_t___invert__(self)
    def __xor__(self, *args) -> "spot::acc_cond::mark_t" : return _impl.mark_t___xor__(self, *args)
    def __lshift__(self, *args) -> "spot::acc_cond::mark_t" : return _impl.mark_t___lshift__(self, *args)
    def __ilshift__(self, *args) -> "spot::acc_cond::mark_t &" : return _impl.mark_t___ilshift__(self, *args)
    def __rshift__(self, *args) -> "spot::acc_cond::mark_t" : return _impl.mark_t___rshift__(self, *args)
    def __irshift__(self, *args) -> "spot::acc_cond::mark_t &" : return _impl.mark_t___irshift__(self, *args)
    def strip(self, *args) -> "spot::acc_cond::mark_t" : return _impl.mark_t_strip(self, *args)
    def count(self) -> "unsigned int" : return _impl.mark_t_count(self)
    def max_set(self) -> "unsigned int" : return _impl.mark_t_max_set(self)
    def lowest(self) -> "spot::acc_cond::mark_t" : return _impl.mark_t_lowest(self)
    def remove_some(self, *args) -> "spot::acc_cond::mark_t &" : return _impl.mark_t_remove_some(self, *args)
    def sets(self) -> "std::vector< unsigned int,std::allocator< unsigned int > >" : return _impl.mark_t_sets(self)
    def __init__(self, *args): 
        _impl.mark_t_swiginit(self,_impl.new_mark_t(*args))
    def __repr__(self) -> "std::string" : return _impl.mark_t___repr__(self)
    def __str__(self) -> "std::string" : return _impl.mark_t___str__(self)
    __swig_destroy__ = _impl.delete_mark_t
mark_t_swigregister = _impl.mark_t_swigregister
mark_t_swigregister(mark_t)

class acc_code(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __eq__(self, *args) -> "bool" : return _impl.acc_code___eq__(self, *args)
    def __lt__(self, *args) -> "bool" : return _impl.acc_code___lt__(self, *args)
    def __gt__(self, *args) -> "bool" : return _impl.acc_code___gt__(self, *args)
    def __le__(self, *args) -> "bool" : return _impl.acc_code___le__(self, *args)
    def __ge__(self, *args) -> "bool" : return _impl.acc_code___ge__(self, *args)
    def __ne__(self, *args) -> "bool" : return _impl.acc_code___ne__(self, *args)
    def is_t(self) -> "bool" : return _impl.acc_code_is_t(self)
    def is_f(self) -> "bool" : return _impl.acc_code_is_f(self)
    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)
    random = staticmethod(_impl.acc_code_random)
    def __iand__(self, *args) -> "spot::acc_cond::acc_code &" : return _impl.acc_code___iand__(self, *args)
    def __and__(self, *args) -> "spot::acc_cond::acc_code" : return _impl.acc_code___and__(self, *args)
    def __ior__(self, *args) -> "spot::acc_cond::acc_code &" : return _impl.acc_code___ior__(self, *args)
    def __or__(self, *args) -> "spot::acc_cond::acc_code" : return _impl.acc_code___or__(self, *args)
    def __ilshift__(self, *args) -> "spot::acc_cond::acc_code &" : return _impl.acc_code___ilshift__(self, *args)
    def __lshift__(self, *args) -> "spot::acc_cond::acc_code" : return _impl.acc_code___lshift__(self, *args)
    def is_dnf(self) -> "bool" : return _impl.acc_code_is_dnf(self)
    def is_cnf(self) -> "bool" : return _impl.acc_code_is_cnf(self)
    def to_dnf(self) -> "spot::acc_cond::acc_code" : return _impl.acc_code_to_dnf(self)
    def to_cnf(self) -> "spot::acc_cond::acc_code" : return _impl.acc_code_to_cnf(self)
    def complement(self) -> "spot::acc_cond::acc_code" : return _impl.acc_code_complement(self)
    def missing(self, *args) -> "std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >" : return _impl.acc_code_missing(self, *args)
    def accepting(self, *args) -> "bool" : return _impl.acc_code_accepting(self, *args)
    def inf_satisfiable(self, *args) -> "bool" : return _impl.acc_code_inf_satisfiable(self, *args)
    def strip(self, *args) -> "spot::acc_cond::acc_code" : return _impl.acc_code_strip(self, *args)
    def used_sets(self) -> "spot::acc_cond::mark_t" : return _impl.acc_code_used_sets(self)
    def used_inf_fin_sets(self) -> "std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t >" : return _impl.acc_code_used_inf_fin_sets(self)
    def to_html(self, *args) -> "std::ostream &" : return _impl.acc_code_to_html(self, *args)
    def to_text(self, *args) -> "std::ostream &" : return _impl.acc_code_to_text(self, *args)
    def __init__(self, *args): 
        _impl.acc_code_swiginit(self,_impl.new_acc_code(*args))
    def __repr__(self) -> "std::string" : return _impl.acc_code___repr__(self)
    def __str__(self) -> "std::string" : return _impl.acc_code___str__(self)
    __swig_destroy__ = _impl.delete_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(*args) -> "spot::acc_cond::acc_code" :
  return _impl.acc_code_generalized_buchi(*args)
acc_code_generalized_buchi = _impl.acc_code_generalized_buchi

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

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

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

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

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


def __lshift__(*args) -> "std::ostream &" :
  return _impl.__lshift__(*args)
__lshift__ = _impl.__lshift__
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
    def compare(self, *args) -> "int" : return _impl.state_compare(self, *args)
    def hash(self) -> "size_t" : return _impl.state_hash(self)
    def clone(self) -> "spot::state *" : return _impl.state_clone(self)
    def destroy(self) -> "void" : return _impl.state_destroy(self)
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 __call__(self, *args) -> "bool" : return _impl.state_ptr_less_than___call__(self, *args)
    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_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 __call__(self, *args) -> "bool" : return _impl.state_ptr_equal___call__(self, *args)
    def __init__(self): 
        _impl.state_ptr_equal_swiginit(self,_impl.new_state_ptr_equal())
    __swig_destroy__ = _impl.delete_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 __call__(self, *args) -> "size_t" : return _impl.state_ptr_hash___call__(self, *args)
    def __init__(self): 
        _impl.state_ptr_hash_swiginit(self,_impl.new_state_ptr_hash())
    __swig_destroy__ = _impl.delete_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
    def __call__(self, *args) -> "spot::state const *" : return _impl.state_unicity_table___call__(self, *args)
    def is_new(self, *args) -> "spot::state const *" : return _impl.state_unicity_table_is_new(self, *args)
    __swig_destroy__ = _impl.delete_state_unicity_table
    def size(self) -> "size_t" : return _impl.state_unicity_table_size(self)
    def __init__(self): 
        _impl.state_unicity_table_swiginit(self,_impl.new_state_unicity_table())
state_unicity_table_swigregister = _impl.state_unicity_table_swigregister
state_unicity_table_swigregister(state_unicity_table)


def shared_state_deleter(*args) -> "void" :
  return _impl.shared_state_deleter(*args)
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 __call__(self, *args) -> "bool" : return _impl.state_shared_ptr_less_than___call__(self, *args)
    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_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 __call__(self, *args) -> "bool" : return _impl.state_shared_ptr_equal___call__(self, *args)
    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_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 __call__(self, *args) -> "size_t" : return _impl.state_shared_ptr_hash___call__(self, *args)
    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_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
    def first(self) -> "bool" : return _impl.twa_succ_iterator_first(self)
    def next(self) -> "bool" : return _impl.twa_succ_iterator_next(self)
    def done(self) -> "bool" : return _impl.twa_succ_iterator_done(self)
    def dst(self) -> "spot::state const *" : return _impl.twa_succ_iterator_dst(self)
    def cond(self) -> "bdd" : return _impl.twa_succ_iterator_cond(self)
    def acc(self) -> "spot::acc_cond::mark_t" : return _impl.twa_succ_iterator_acc(self)
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, *args): 
        _impl.succ_iterator_swiginit(self,_impl.new_succ_iterator(*args))
    def __eq__(self, *args) -> "bool" : return _impl.succ_iterator___eq__(self, *args)
    def __ne__(self, *args) -> "bool" : return _impl.succ_iterator___ne__(self, *args)
    def __ref__(self) -> "spot::twa_succ_iterator const *" : return _impl.succ_iterator___ref__(self)
    __swig_destroy__ = _impl.delete_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 get_init_state(self) -> "spot::state const *" : return _impl.twa_get_init_state(self)
    def succ_iter(self, *args) -> "spot::twa_succ_iterator *" : return _impl.twa_succ_iter(self, *args)
    def release_iter(self, *args) -> "void" : return _impl.twa_release_iter(self, *args)
    def get_dict(self) -> "spot::bdd_dict_ptr" : return _impl.twa_get_dict(self)
    def register_ap(self, *args) -> "int" : return _impl.twa_register_ap(self, *args)
    def unregister_ap(self, *args) -> "void" : return _impl.twa_unregister_ap(self, *args)
    def register_aps_from_dict(self) -> "void" : return _impl.twa_register_aps_from_dict(self)
    def ap(self) -> "std::vector< spot::formula,std::allocator< spot::formula > > const &" : return _impl.twa_ap(self)
    def ap_vars(self) -> "bdd" : return _impl.twa_ap_vars(self)
    def format_state(self, *args) -> "std::string" : return _impl.twa_format_state(self, *args)
    def project_state(self, *args) -> "spot::state *" : return _impl.twa_project_state(self, *args)
    def acc(self, *args) -> "spot::acc_cond &" : return _impl.twa_acc(self, *args)
    def is_empty(self) -> "bool" : return _impl.twa_is_empty(self)
    def accepting_run(self) -> "spot::twa_run_ptr" : return _impl.twa_accepting_run(self)
    def accepting_word(self) -> "spot::twa_word_ptr" : return _impl.twa_accepting_word(self)
    def intersects(self, *args) -> "bool" : return _impl.twa_intersects(self, *args)
    def intersecting_run(self, *args) -> "spot::twa_run_ptr" : return _impl.twa_intersecting_run(self, *args)
    def intersecting_word(self, *args) -> "spot::twa_word_ptr" : return _impl.twa_intersecting_word(self, *args)
    def num_sets(self) -> "unsigned int" : return _impl.twa_num_sets(self)
    def get_acceptance(self) -> "spot::acc_cond::acc_code const &" : return _impl.twa_get_acceptance(self)
    def set_acceptance(self, *args) -> "void" : return _impl.twa_set_acceptance(self, *args)
    def copy_acceptance_of(self, *args) -> "void" : return _impl.twa_copy_acceptance_of(self, *args)
    def copy_ap_of(self, *args) -> "void" : return _impl.twa_copy_ap_of(self, *args)
    def set_generalized_buchi(self, *args) -> "void" : return _impl.twa_set_generalized_buchi(self, *args)
    def set_buchi(self) -> "spot::acc_cond::mark_t" : return _impl.twa_set_buchi(self)
    def release_named_properties(self) -> "void" : return _impl.twa_release_named_properties(self)
    def prop_state_acc(self, *args) -> "void" : return _impl.twa_prop_state_acc(self, *args)
    def is_sba(self) -> "spot::trival" : return _impl.twa_is_sba(self)
    def prop_inherently_weak(self, *args) -> "void" : return _impl.twa_prop_inherently_weak(self, *args)
    def prop_terminal(self, *args) -> "void" : return _impl.twa_prop_terminal(self, *args)
    def prop_weak(self, *args) -> "void" : return _impl.twa_prop_weak(self, *args)
    def prop_very_weak(self, *args) -> "void" : return _impl.twa_prop_very_weak(self, *args)
    def prop_deterministic(self, *args) -> "void" : return _impl.twa_prop_deterministic(self, *args)
    def prop_unambiguous(self, *args) -> "void" : return _impl.twa_prop_unambiguous(self, *args)
    def prop_semi_deterministic(self, *args) -> "void" : return _impl.twa_prop_semi_deterministic(self, *args)
    def prop_stutter_invariant(self, *args) -> "void" : return _impl.twa_prop_stutter_invariant(self, *args)
    def prop_copy(self, *args) -> "void" : return _impl.twa_prop_copy(self, *args)
    def prop_keep(self, *args) -> "void" : return _impl.twa_prop_keep(self, *args)
    def set_name(self, *args) -> "void" : return _impl.twa_set_name(self, *args)
    def get_name(self) -> "std::string *" : return _impl.twa_get_name(self)
    def set_state_names(self, *args) -> "void" : return _impl.twa_set_state_names(self, *args)
    def get_state_names(self) -> "std::vector< std::string,std::allocator< std::string > > *" : return _impl.twa_get_state_names(self)
    def highlight_state(self, *args) -> "spot::twa *" : return _impl.twa_highlight_state(self, *args)
    def highlight_edge(self, *args) -> "spot::twa *" : return _impl.twa_highlight_edge(self, *args)
twa_swigregister = _impl.twa_swigregister
twa_swigregister(twa)


def create_atomic_prop_set(*args) -> "spot::atomic_prop_set" :
  return _impl.create_atomic_prop_set(*args)
create_atomic_prop_set = _impl.create_atomic_prop_set

def atomic_prop_collect(*args) -> "spot::atomic_prop_set *" :
  return _impl.atomic_prop_collect(*args)
atomic_prop_collect = _impl.atomic_prop_collect

def atomic_prop_collect_as_bdd(*args) -> "bdd" :
  return _impl.atomic_prop_collect_as_bdd(*args)
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
    def clear(self) -> "void" : return _impl.language_containment_checker_clear(self)
    def contained(self, *args) -> "bool" : return _impl.language_containment_checker_contained(self, *args)
    def neg_contained(self, *args) -> "bool" : return _impl.language_containment_checker_neg_contained(self, *args)
    def contained_neg(self, *args) -> "bool" : return _impl.language_containment_checker_contained_neg(self, *args)
    def equal(self, *args) -> "bool" : return _impl.language_containment_checker_equal(self, *args)
language_containment_checker_swigregister = _impl.language_containment_checker_swigregister
language_containment_checker_swigregister(language_containment_checker)


def print_dot_psl(*args) -> "std::ostream &" :
  return _impl.print_dot_psl(*args)
print_dot_psl = _impl.print_dot_psl

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

def print_psl(*args) -> "std::ostream &" :
  return _impl.print_psl(*args)
print_psl = _impl.print_psl

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

def print_utf8_psl(*args) -> "std::ostream &" :
  return _impl.print_utf8_psl(*args)
print_utf8_psl = _impl.print_utf8_psl

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

def print_sere(*args) -> "std::ostream &" :
  return _impl.print_sere(*args)
print_sere = _impl.print_sere

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

def print_utf8_sere(*args) -> "std::ostream &" :
  return _impl.print_utf8_sere(*args)
print_utf8_sere = _impl.print_utf8_sere

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

def print_spin_ltl(*args) -> "std::ostream &" :
  return _impl.print_spin_ltl(*args)
print_spin_ltl = _impl.print_spin_ltl

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

def print_wring_ltl(*args) -> "std::ostream &" :
  return _impl.print_wring_ltl(*args)
print_wring_ltl = _impl.print_wring_ltl

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

def print_latex_psl(*args) -> "std::ostream &" :
  return _impl.print_latex_psl(*args)
print_latex_psl = _impl.print_latex_psl

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

def print_latex_sere(*args) -> "std::ostream &" :
  return _impl.print_latex_sere(*args)
print_latex_sere = _impl.print_latex_sere

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

def print_sclatex_psl(*args) -> "std::ostream &" :
  return _impl.print_sclatex_psl(*args)
print_sclatex_psl = _impl.print_sclatex_psl

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

def print_sclatex_sere(*args) -> "std::ostream &" :
  return _impl.print_sclatex_sere(*args)
print_sclatex_sere = _impl.print_sclatex_sere

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

def print_lbt_ltl(*args) -> "std::ostream &" :
  return _impl.print_lbt_ltl(*args)
print_lbt_ltl = _impl.print_lbt_ltl

def str_lbt_ltl(*args) -> "std::string" :
  return _impl.str_lbt_ltl(*args)
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)
    __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
    def simplify(self, *args) -> "spot::formula" : return _impl.tl_simplifier_simplify(self, *args)
    def negative_normal_form(self, *args) -> "spot::formula" : return _impl.tl_simplifier_negative_normal_form(self, *args)
    def syntactic_implication(self, *args) -> "bool" : return _impl.tl_simplifier_syntactic_implication(self, *args)
    def syntactic_implication_neg(self, *args) -> "bool" : return _impl.tl_simplifier_syntactic_implication_neg(self, *args)
    def are_equivalent(self, *args) -> "bool" : return _impl.tl_simplifier_are_equivalent(self, *args)
    def implication(self, *args) -> "bool" : return _impl.tl_simplifier_implication(self, *args)
    def as_bdd(self, *args) -> "bdd" : return _impl.tl_simplifier_as_bdd(self, *args)
    def clear_as_bdd_cache(self) -> "void" : return _impl.tl_simplifier_clear_as_bdd_cache(self)
    def get_dict(self) -> "spot::bdd_dict_ptr" : return _impl.tl_simplifier_get_dict(self)
    def star_normal_form(self, *args) -> "spot::formula" : return _impl.tl_simplifier_star_normal_form(self, *args)
    def boolean_to_isop(self, *args) -> "spot::formula" : return _impl.tl_simplifier_boolean_to_isop(self, *args)
    def print_stats(self, *args) -> "void" : return _impl.tl_simplifier_print_stats(self, *args)
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))
    def run(self, *args) -> "spot::formula" : return _impl.unabbreviator_run(self, *args)
    __swig_destroy__ = _impl.delete_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
OUTPUTBOOL = _impl.OUTPUTBOOL
OUTPUTLTL = _impl.OUTPUTLTL
OUTPUTSERE = _impl.OUTPUTSERE
OUTPUTPSL = _impl.OUTPUTPSL
MAX_TRIALS = _impl.MAX_TRIALS
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, *args): 
        _impl.random_formula_swiginit(self,_impl.new_random_formula(*args))
    __swig_destroy__ = _impl.delete_random_formula
    def ap(self) -> "spot::atomic_prop_set const *" : return _impl.random_formula_ap(self)
    def generate(self, *args) -> "spot::formula" : return _impl.random_formula_generate(self, *args)
    def dump_priorities(self, *args) -> "std::ostream &" : return _impl.random_formula_dump_priorities(self, *args)
    def parse_options(self, *args) -> "char const *" : return _impl.random_formula_parse_options(self, *args)
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, *args): 
        _impl.random_ltl_swiginit(self,_impl.new_random_ltl(*args))
    __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, *args): 
        _impl.random_boolean_swiginit(self,_impl.new_random_boolean(*args))
    __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, *args): 
        _impl.random_sere_swiginit(self,_impl.new_random_sere(*args))
    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, *args): 
        _impl.random_psl_swiginit(self,_impl.new_random_psl(*args))
    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
    def __init__(self, *args): 
        _impl.randltlgenerator_swiginit(self,_impl.new_randltlgenerator(*args))
    __swig_destroy__ = _impl.delete_randltlgenerator
    def next(self) -> "spot::formula" : return _impl.randltlgenerator_next(self)
    def dump_ltl_priorities(self, *args) -> "void" : return _impl.randltlgenerator_dump_ltl_priorities(self, *args)
    def dump_bool_priorities(self, *args) -> "void" : return _impl.randltlgenerator_dump_bool_priorities(self, *args)
    def dump_psl_priorities(self, *args) -> "void" : return _impl.randltlgenerator_dump_psl_priorities(self, *args)
    def dump_sere_priorities(self, *args) -> "void" : return _impl.randltlgenerator_dump_sere_priorities(self, *args)
    def dump_sere_bool_priorities(self, *args) -> "void" : return _impl.randltlgenerator_dump_sere_bool_priorities(self, *args)
    def remove_some_props(self, *args) -> "void" : return _impl.randltlgenerator_remove_some_props(self, *args)
    def GF_n(self) -> "spot::formula" : return _impl.randltlgenerator_GF_n(self)
randltlgenerator_swigregister = _impl.randltlgenerator_swigregister
randltlgenerator_swigregister(randltlgenerator)


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

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

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

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

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

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

def relabel_bse(*args) -> "spot::formula" :
  return _impl.relabel_bse(*args)
relabel_bse = _impl.relabel_bse
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
    def add_condition(self, *args) -> "void" : return _impl.taa_tgba_add_condition(self, *args)
    __swig_destroy__ = _impl.delete_taa_tgba
    def get_init_state(self) -> "spot::state *" : return _impl.taa_tgba_get_init_state(self)
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, *args): 
        _impl.set_state_swiginit(self,_impl.new_set_state(*args))
    def clone(self) -> "spot::set_state *" : return _impl.set_state_clone(self)
    __swig_destroy__ = _impl.delete_set_state
    def get_state(self) -> "spot::taa_tgba::state_set const *" : return _impl.set_state_get_state(self)
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, *args): 
        _impl.taa_succ_iterator_swiginit(self,_impl.new_taa_succ_iterator(*args))
    __swig_destroy__ = _impl.delete_taa_succ_iterator
    def dst(self) -> "spot::set_state *" : return _impl.taa_succ_iterator_dst(self)
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(*args) -> "spot::taa_tgba_string_ptr" :
  return _impl.make_taa_tgba_string(*args)
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(*args) -> "spot::taa_tgba_formula_ptr" :
  return _impl.make_taa_tgba_formula(*args)
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, *args): 
        _impl.state_product_swiginit(self,_impl.new_state_product(*args))
    def left(self) -> "spot::state const *" : return _impl.state_product_left(self)
    def right(self) -> "spot::state const *" : return _impl.state_product_right(self)
    def clone(self) -> "spot::state_product *" : return _impl.state_product_clone(self)
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, *args): 
        _impl.twa_product_swiginit(self,_impl.new_twa_product(*args))
    __swig_destroy__ = _impl.delete_twa_product
    def left_acc(self) -> "spot::acc_cond const &" : return _impl.twa_product_left_acc(self)
    def right_acc(self) -> "spot::acc_cond const &" : return _impl.twa_product_right_acc(self)
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, *args): 
        _impl.twa_product_init_swiginit(self,_impl.new_twa_product_init(*args))
    __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(*args) -> "spot::twa_product_ptr" :
  return _impl.otf_product(*args)
otf_product = _impl.otf_product

def otf_product_at(*args) -> "spot::twa_product_ptr" :
  return _impl.otf_product_at(*args)
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))
    def begin(self) -> "unsigned int const *" : return _impl.const_universal_dests_begin(self)
    def end(self) -> "unsigned int const *" : return _impl.const_universal_dests_end(self)
    def __iter__(self) -> "swig::SwigPyIterator *" : return _impl.const_universal_dests___iter__(self)
    __swig_destroy__ = _impl.delete_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): 
        _impl.twa_graph_state_swiginit(self,_impl.new_twa_graph_state())
    __swig_destroy__ = _impl.delete_twa_graph_state
    def clone(self) -> "spot::twa_graph_state *" : return _impl.twa_graph_state_clone(self)
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))
    def __lt__(self, *args) -> "bool" : return _impl.twa_graph_edge_data___lt__(self, *args)
    def __eq__(self, *args) -> "bool" : return _impl.twa_graph_edge_data___eq__(self, *args)
    __swig_destroy__ = _impl.delete_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
    def get_graph(self, *args) -> "spot::twa_graph::graph_t const &" : return _impl.twa_graph_get_graph(self, *args)
    def num_states(self) -> "unsigned int" : return _impl.twa_graph_num_states(self)
    def num_edges(self) -> "unsigned int" : return _impl.twa_graph_num_edges(self)
    def set_init_state(self, *args) -> "void" : return _impl.twa_graph_set_init_state(self, *args)
    def get_init_state_number(self) -> "spot::twa_graph::state_num" : return _impl.twa_graph_get_init_state_number(self)
    def get_init_state(self) -> "spot::twa_graph_state const *" : return _impl.twa_graph_get_init_state(self)
    is_univ_dest = staticmethod(_impl.twa_graph_is_univ_dest)
    def state_number(self, *args) -> "spot::twa_graph::state_num" : return _impl.twa_graph_state_number(self, *args)
    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 format_state(self, *args) -> "std::string" : return _impl.twa_graph_format_state(self, *args)
    def edge_number(self, *args) -> "unsigned int" : return _impl.twa_graph_edge_number(self, *args)
    def edge_data(self, *args) -> "spot::twa_graph_edge_data const &" : return _impl.twa_graph_edge_data(self, *args)
    def edge_storage(self, *args) -> "spot::twa_graph::edge_storage_t const" : return _impl.twa_graph_edge_storage(self, *args)
    def new_state(self) -> "unsigned int" : return _impl.twa_graph_new_state(self)
    def new_states(self, *args) -> "unsigned int" : return _impl.twa_graph_new_states(self, *args)
    def new_edge(self, *args) -> "unsigned int" : return _impl.twa_graph_new_edge(self, *args)
    def new_acc_edge(self, *args) -> "unsigned int" : return _impl.twa_graph_new_acc_edge(self, *args)
    def out(self, src: 'unsigned int'):
        self.report_univ_dest(src)
        return _impl.twa_graph_out(self, src)


    def univ_dests(self, *args) -> "spot::internal::const_universal_dests" : return _impl.twa_graph_univ_dests(self, *args)
    def is_existential(self) -> "bool" : return _impl.twa_graph_is_existential(self)
    def edges(self) -> "spot::internal::all_trans< spot::twa_graph::graph_t >" : return _impl.twa_graph_edges(self)
    def merge_edges(self) -> "void" : return _impl.twa_graph_merge_edges(self)
    def merge_univ_dests(self) -> "void" : return _impl.twa_graph_merge_univ_dests(self)
    def purge_dead_states(self) -> "void" : return _impl.twa_graph_purge_dead_states(self)
    def purge_unreachable_states(self) -> "void" : return _impl.twa_graph_purge_unreachable_states(self)
    def remove_unused_ap(self) -> "void" : return _impl.twa_graph_remove_unused_ap(self)
    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)


    def __eq__(self, *args) -> "bool" : return _impl.twa_graph___eq__(self, *args)
    def defrag_states(self, *args) -> "void" : return _impl.twa_graph_defrag_states(self, *args)
    def new_univ_edge(self, *args) -> "unsigned int" : return _impl.twa_graph_new_univ_edge(self, *args)
    def set_univ_init_state(self, *args) -> "void" : return _impl.twa_graph_set_univ_init_state(self, *args)
    def report_univ_dest(self, *args) -> "void" : return _impl.twa_graph_report_univ_dest(self, *args)
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, *args): 
        _impl.twa_graph_state_out_swiginit(self,_impl.new_twa_graph_state_out(*args))
    def begin(self) -> "spot::internal::edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >" : return _impl.twa_graph_state_out_begin(self)
    def end(self) -> "spot::internal::edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >" : return _impl.twa_graph_state_out_end(self)
    def recycle(self, *args) -> "void" : return _impl.twa_graph_state_out_recycle(self, *args)
    def __iter__(self) -> "swig::SwigPyIterator *" : return _impl.twa_graph_state_out___iter__(self)
    __swig_destroy__ = _impl.delete_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_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, *args): 
        _impl.twa_graph_all_trans_swiginit(self,_impl.new_twa_graph_all_trans(*args))
    def begin(self) -> "spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::iter_t" : return _impl.twa_graph_all_trans_begin(self)
    def end(self) -> "spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::iter_t" : return _impl.twa_graph_all_trans_end(self)
    def __iter__(self) -> "swig::SwigPyIterator *" : return _impl.twa_graph_all_trans___iter__(self)
    __swig_destroy__ = _impl.delete_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())
    def data(self, *args) -> "spot::twa_graph_edge_data const &" : return _impl.twa_graph_edge_boxed_data_data(self, *args)
    __swig_destroy__ = _impl.delete_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())
    def __lt__(self, *args) -> "bool" : return _impl.twa_graph_edge_storage___lt__(self, *args)
    def __eq__(self, *args) -> "bool" : return _impl.twa_graph_edge_storage___eq__(self, *args)
    __swig_destroy__ = _impl.delete_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, *args): 
        _impl.outedge_combiner_swiginit(self,_impl.new_outedge_combiner(*args))
    __swig_destroy__ = _impl.delete_outedge_combiner
    def __call__(self, *args) -> "bdd" : return _impl.outedge_combiner___call__(self, *args)
    def new_dests(self, *args) -> "void" : return _impl.outedge_combiner_new_dests(self, *args)
outedge_combiner_swigregister = _impl.outedge_combiner_swigregister
outedge_combiner_swigregister(outedge_combiner)


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

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

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

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

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

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

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

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

def dtwa_complement(*args) -> "spot::twa_graph_ptr" :
  return _impl.dtwa_complement(*args)
dtwa_complement = _impl.dtwa_complement
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
    def accepting_run(self) -> "spot::twa_run_ptr" : return _impl.emptiness_check_result_accepting_run(self)
    def automaton(self) -> "spot::const_twa_ptr const &" : return _impl.emptiness_check_result_automaton(self)
    def options(self) -> "spot::option_map const &" : return _impl.emptiness_check_result_options(self)
    def parse_options(self, *args) -> "char const *" : return _impl.emptiness_check_result_parse_options(self, *args)
    def statistics(self) -> "unsigned_statistics const *" : return _impl.emptiness_check_result_statistics(self)
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
    def automaton(self) -> "spot::const_twa_ptr const &" : return _impl.emptiness_check_automaton(self)
    def options(self) -> "spot::option_map const &" : return _impl.emptiness_check_options(self)
    def parse_options(self, *args) -> "char const *" : return _impl.emptiness_check_parse_options(self, *args)
    def safe(self) -> "bool" : return _impl.emptiness_check_safe(self)
    def check(self) -> "spot::emptiness_check_result_ptr" : return _impl.emptiness_check_check(self)
    def statistics(self) -> "unsigned_statistics const *" : return _impl.emptiness_check_statistics(self)
    def emptiness_check_statistics(self) -> "ec_statistics const *" : return _impl.emptiness_check_emptiness_check_statistics(self)
    def print_stats(self, *args) -> "std::ostream &" : return _impl.emptiness_check_print_stats(self, *args)
    def options_updated(self, *args) -> "void" : return _impl.emptiness_check_options_updated(self, *args)
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
    def instantiate(self, *args) -> "spot::emptiness_check_ptr" : return _impl.emptiness_check_instantiator_instantiate(self, *args)
    def options(self, *args) -> "spot::option_map &" : return _impl.emptiness_check_instantiator_options(self, *args)
    def min_sets(self) -> "unsigned int" : return _impl.emptiness_check_instantiator_min_sets(self)
    def max_sets(self) -> "unsigned int" : return _impl.emptiness_check_instantiator_max_sets(self)
    __swig_destroy__ = _impl.delete_emptiness_check_instantiator
emptiness_check_instantiator_swigregister = _impl.emptiness_check_instantiator_swigregister
emptiness_check_instantiator_swigregister(emptiness_check_instantiator)


def make_emptiness_check_instantiator(*args) -> "char **" :
  return _impl.make_emptiness_check_instantiator(*args)
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')
    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))
    def reduce(self) -> "spot::twa_run_ptr" : return _impl.twa_run_reduce(self)
    def project(self, *args) -> "spot::twa_run_ptr" : return _impl.twa_run_project(self, *args)
    def replay(self, *args) -> "bool" : return _impl.twa_run_replay(self, *args)
    def highlight(self, *args) -> "void" : return _impl.twa_run_highlight(self, *args)
    def as_twa(self, preserve_names : 'bool'=False) -> "spot::twa_graph_ptr" : return _impl.twa_run_as_twa(self, preserve_names)
    def __repr__(self) -> "std::string" : return _impl.twa_run___repr__(self)
    def __str__(self) -> "std::string" : return _impl.twa_run___str__(self)
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 iterator(self) -> "swig::SwigPyIterator *" : return _impl.list_step_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self) -> "bool" : return _impl.list_step___nonzero__(self)
    def __bool__(self) -> "bool" : return _impl.list_step___bool__(self)
    def __len__(self) -> "std::list< spot::twa_run::step >::size_type" : return _impl.list_step___len__(self)
    def pop(self) -> "std::list< spot::twa_run::step >::value_type" : return _impl.list_step_pop(self)
    def __getslice__(self, *args) -> "std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > > *" : return _impl.list_step___getslice__(self, *args)
    def __setslice__(self, *args) -> "void" : return _impl.list_step___setslice__(self, *args)
    def __delslice__(self, *args) -> "void" : return _impl.list_step___delslice__(self, *args)
    def __delitem__(self, *args) -> "void" : return _impl.list_step___delitem__(self, *args)
    def __getitem__(self, *args) -> "std::list< spot::twa_run::step >::value_type const &" : return _impl.list_step___getitem__(self, *args)
    def __setitem__(self, *args) -> "void" : return _impl.list_step___setitem__(self, *args)
    def append(self, *args) -> "void" : return _impl.list_step_append(self, *args)
    def empty(self) -> "bool" : return _impl.list_step_empty(self)
    def size(self) -> "std::list< spot::twa_run::step >::size_type" : return _impl.list_step_size(self)
    def clear(self) -> "void" : return _impl.list_step_clear(self)
    def swap(self, *args) -> "void" : return _impl.list_step_swap(self, *args)
    def get_allocator(self) -> "std::list< spot::twa_run::step >::allocator_type" : return _impl.list_step_get_allocator(self)
    def begin(self) -> "std::list< spot::twa_run::step >::iterator" : return _impl.list_step_begin(self)
    def end(self) -> "std::list< spot::twa_run::step >::iterator" : return _impl.list_step_end(self)
    def rbegin(self) -> "std::list< spot::twa_run::step >::reverse_iterator" : return _impl.list_step_rbegin(self)
    def rend(self) -> "std::list< spot::twa_run::step >::reverse_iterator" : return _impl.list_step_rend(self)
    def pop_back(self) -> "void" : return _impl.list_step_pop_back(self)
    def erase(self, *args) -> "std::list< spot::twa_run::step >::iterator" : return _impl.list_step_erase(self, *args)
    def __init__(self, *args): 
        _impl.list_step_swiginit(self,_impl.new_list_step(*args))
    def push_back(self, *args) -> "void" : return _impl.list_step_push_back(self, *args)
    def front(self) -> "std::list< spot::twa_run::step >::value_type const &" : return _impl.list_step_front(self)
    def back(self) -> "std::list< spot::twa_run::step >::value_type const &" : return _impl.list_step_back(self)
    def assign(self, *args) -> "void" : return _impl.list_step_assign(self, *args)
    def resize(self, *args) -> "void" : return _impl.list_step_resize(self, *args)
    def insert(self, *args) -> "void" : return _impl.list_step_insert(self, *args)
    def pop_front(self) -> "void" : return _impl.list_step_pop_front(self)
    def push_front(self, *args) -> "void" : return _impl.list_step_push_front(self, *args)
    def reverse(self) -> "void" : return _impl.list_step_reverse(self)
    __swig_destroy__ = _impl.delete_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 print_lbtt(*args) -> "std::ostream &" :
  return _impl.print_lbtt(*args)
print_lbtt = _impl.print_lbtt

def ltl_to_taa(*args) -> "spot::taa_tgba_formula_ptr" :
  return _impl.ltl_to_taa(*args)
ltl_to_taa = _impl.ltl_to_taa

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

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

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

def language_map(*args) -> "std::vector< unsigned int,std::allocator< unsigned int > >" :
  return _impl.language_map(*args)
language_map = _impl.language_map

def highlight_languages(*args) -> "void" :
  return _impl.highlight_languages(*args)
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(*args) -> "spot::twa_graph_ptr" :
  return _impl.minimize_monitor(*args)
minimize_monitor = _impl.minimize_monitor

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

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

def print_never_claim(*args) -> "std::ostream &" :
  return _impl.print_never_claim(*args)
print_never_claim = _impl.print_never_claim

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def scc_filter_susp(*args) -> "spot::twa_graph_ptr" :
  return _impl.scc_filter_susp(*args)
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())
    def dump(self, *args) -> "std::ostream &" : return _impl.twa_statistics_dump(self, *args)
    __swig_destroy__ = _impl.delete_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())
    def dump(self, *args) -> "std::ostream &" : return _impl.twa_sub_statistics_dump(self, *args)
    __swig_destroy__ = _impl.delete_twa_sub_statistics
twa_sub_statistics_swigregister = _impl.twa_sub_statistics_swigregister
twa_sub_statistics_swigregister(twa_sub_statistics)


def sub_stats_reachable(*args) -> "spot::twa_sub_statistics" :
  return _impl.sub_stats_reachable(*args)
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 _print(self, *args) -> "void" : return _impl.printable_formula__print(self, *args)
    def __init__(self): 
        _impl.printable_formula_swiginit(self,_impl.new_printable_formula())
    __swig_destroy__ = _impl.delete_printable_formula
printable_formula_swigregister = _impl.printable_formula_swigregister
printable_formula_swigregister(printable_formula)

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 automaton(self, *args) -> "void" : return _impl.printable_scc_info_automaton(self, *args)
    def reset(self) -> "void" : return _impl.printable_scc_info_reset(self)
    def _print(self, *args) -> "void" : return _impl.printable_scc_info__print(self, *args)
    def __init__(self): 
        _impl.printable_scc_info_swiginit(self,_impl.new_printable_scc_info())
    __swig_destroy__ = _impl.delete_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, *args): 
        _impl.stat_printer_swiginit(self,_impl.new_stat_printer(*args))
    def _print(self, *args) -> "std::ostream &" : return _impl.stat_printer__print(self, *args)
    __swig_destroy__ = _impl.delete_stat_printer
stat_printer_swigregister = _impl.stat_printer_swigregister
stat_printer_swigregister(stat_printer)


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

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

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

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

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

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

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

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

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

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

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

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

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

def iterated_simulations_sba(*args) -> "spot::twa_graph_ptr" :
  return _impl.iterated_simulations_sba(*args)
iterated_simulations_sba = _impl.iterated_simulations_sba
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
    def set_type(self, *args) -> "void" : return _impl.postprocessor_set_type(self, *args)
    Any = _impl.postprocessor_Any
    Small = _impl.postprocessor_Small
    Deterministic = _impl.postprocessor_Deterministic
    Complete = _impl.postprocessor_Complete
    SBAcc = _impl.postprocessor_SBAcc
    Unambiguous = _impl.postprocessor_Unambiguous
    def set_pref(self, *args) -> "void" : return _impl.postprocessor_set_pref(self, *args)
    Low = _impl.postprocessor_Low
    Medium = _impl.postprocessor_Medium
    High = _impl.postprocessor_High
    def set_level(self, *args) -> "void" : return _impl.postprocessor_set_level(self, *args)
    def run(self, *args) -> "spot::twa_graph_ptr" : return _impl.postprocessor_run(self, *args)
    __swig_destroy__ = _impl.delete_postprocessor
postprocessor_swigregister = _impl.postprocessor_swigregister
postprocessor_swigregister(postprocessor)


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 sl(*args) -> "spot::twa_graph_ptr" :
  return _impl.sl(*args)
sl = _impl.sl

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

def closure(*args) -> "spot::twa_graph_ptr" :
  return _impl.closure(*args)
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(*args) -> "spot::trival" :
  return _impl.check_stutter_invariance(*args)
check_stutter_invariance = _impl.check_stutter_invariance
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
    def set_type(self, *args) -> "void" : return _impl.translator_set_type(self, *args)
    def set_pref(self, *args) -> "void" : return _impl.translator_set_pref(self, *args)
    def set_level(self, *args) -> "void" : return _impl.translator_set_level(self, *args)
    def run(self, *args) -> "spot::twa_graph_ptr" : return _impl.translator_run(self, *args)
translator_swigregister = _impl.translator_swigregister
translator_swigregister(translator)


def print_hoa(*args) -> "std::ostream &" :
  return _impl.print_hoa(*args)
print_hoa = _impl.print_hoa

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

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

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

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

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

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

def relabel_here(*args) -> "void" :
  return _impl.relabel_here(*args)
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')
    def __init__(self, *args): 
        _impl.twa_word_swiginit(self,_impl.new_twa_word(*args))
    __swig_destroy__ = _impl.delete_twa_word
    def simplify(self) -> "void" : return _impl.twa_word_simplify(self)
    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)
    def get_dict(self) -> "spot::bdd_dict_ptr" : return _impl.twa_word_get_dict(self)
    def as_automaton(self) -> "spot::twa_graph_ptr" : return _impl.twa_word_as_automaton(self)
    def __repr__(self) -> "std::string" : return _impl.twa_word___repr__(self)
    def __str__(self) -> "std::string" : return _impl.twa_word___str__(self)
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(*args) -> "spot::twa_word_ptr" :
  return _impl.parse_word(*args)
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 iterator(self) -> "swig::SwigPyIterator *" : return _impl.list_bdd_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self) -> "bool" : return _impl.list_bdd___nonzero__(self)
    def __bool__(self) -> "bool" : return _impl.list_bdd___bool__(self)
    def __len__(self) -> "std::list< bdd >::size_type" : return _impl.list_bdd___len__(self)
    def pop(self) -> "std::list< bdd >::value_type" : return _impl.list_bdd_pop(self)
    def __getslice__(self, *args) -> "std::list< bdd,std::allocator< bdd > > *" : return _impl.list_bdd___getslice__(self, *args)
    def __setslice__(self, *args) -> "void" : return _impl.list_bdd___setslice__(self, *args)
    def __delslice__(self, *args) -> "void" : return _impl.list_bdd___delslice__(self, *args)
    def __delitem__(self, *args) -> "void" : return _impl.list_bdd___delitem__(self, *args)
    def __getitem__(self, *args) -> "std::list< bdd >::value_type const &" : return _impl.list_bdd___getitem__(self, *args)
    def __setitem__(self, *args) -> "void" : return _impl.list_bdd___setitem__(self, *args)
    def append(self, *args) -> "void" : return _impl.list_bdd_append(self, *args)
    def empty(self) -> "bool" : return _impl.list_bdd_empty(self)
    def size(self) -> "std::list< bdd >::size_type" : return _impl.list_bdd_size(self)
    def clear(self) -> "void" : return _impl.list_bdd_clear(self)
    def swap(self, *args) -> "void" : return _impl.list_bdd_swap(self, *args)
    def get_allocator(self) -> "std::list< bdd >::allocator_type" : return _impl.list_bdd_get_allocator(self)
    def begin(self) -> "std::list< bdd >::iterator" : return _impl.list_bdd_begin(self)
    def end(self) -> "std::list< bdd >::iterator" : return _impl.list_bdd_end(self)
    def rbegin(self) -> "std::list< bdd >::reverse_iterator" : return _impl.list_bdd_rbegin(self)
    def rend(self) -> "std::list< bdd >::reverse_iterator" : return _impl.list_bdd_rend(self)
    def pop_back(self) -> "void" : return _impl.list_bdd_pop_back(self)
    def erase(self, *args) -> "std::list< bdd >::iterator" : return _impl.list_bdd_erase(self, *args)
    def __init__(self, *args): 
        _impl.list_bdd_swiginit(self,_impl.new_list_bdd(*args))
    def push_back(self, *args) -> "void" : return _impl.list_bdd_push_back(self, *args)
    def front(self) -> "std::list< bdd >::value_type const &" : return _impl.list_bdd_front(self)
    def back(self) -> "std::list< bdd >::value_type const &" : return _impl.list_bdd_back(self)
    def assign(self, *args) -> "void" : return _impl.list_bdd_assign(self, *args)
    def resize(self, *args) -> "void" : return _impl.list_bdd_resize(self, *args)
    def insert(self, *args) -> "void" : return _impl.list_bdd_insert(self, *args)
    def pop_front(self) -> "void" : return _impl.list_bdd_pop_front(self)
    def push_front(self, *args) -> "void" : return _impl.list_bdd_push_front(self, *args)
    def reverse(self) -> "void" : return _impl.list_bdd_reverse(self)
    __swig_destroy__ = _impl.delete_list_bdd
list_bdd_swigregister = _impl.list_bdd_swigregister
list_bdd_swigregister(list_bdd)

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 __nonzero__(self) -> "bool" : return _impl.parse_aut_error_list___nonzero__(self)
    def __bool__(self) -> "bool" : return _impl.parse_aut_error_list___bool__(self)
    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_swigregister = _impl.parse_aut_error_list_swigregister
parse_aut_error_list_swigregister(parse_aut_error_list)

HOA = _impl.HOA
NeverClaim = _impl.NeverClaim
LBTT = _impl.LBTT
DRA = _impl.DRA
DSA = _impl.DSA
Unknown = _impl.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, *args): 
        _impl.parsed_aut_swiginit(self,_impl.new_parsed_aut(*args))
    def format_errors(self, *args) -> "bool" : return _impl.parsed_aut_format_errors(self, *args)
    __swig_destroy__ = _impl.delete_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
    def parse(self, *args) -> "spot::parsed_aut_ptr" : return _impl.automaton_stream_parser_parse(self, *args)
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 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
    def state_condition(self, *args) -> "bdd" : return _impl.fair_kripke_state_condition(self, *args)
    def state_acceptance_mark(self, *args) -> "spot::acc_cond::mark_t" : return _impl.fair_kripke_state_acceptance_mark(self, *args)
    __swig_destroy__ = _impl.delete_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
    def recycle(self, *args) -> "void" : return _impl.kripke_succ_iterator_recycle(self, *args)
    __swig_destroy__ = _impl.delete_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 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
    def get_initial_states_set(self) -> "spot::ta::const_states_set_t" : return _impl.ta_get_initial_states_set(self)
    def get_artificial_initial_state(self) -> "spot::state const *" : return _impl.ta_get_artificial_initial_state(self)
    def succ_iter(self, *args) -> "spot::ta_succ_iterator *" : return _impl.ta_succ_iter(self, *args)
    def get_dict(self) -> "spot::bdd_dict_ptr" : return _impl.ta_get_dict(self)
    def format_state(self, *args) -> "std::string" : return _impl.ta_format_state(self, *args)
    def is_accepting_state(self, *args) -> "bool" : return _impl.ta_is_accepting_state(self, *args)
    def is_livelock_accepting_state(self, *args) -> "bool" : return _impl.ta_is_livelock_accepting_state(self, *args)
    def is_initial_state(self, *args) -> "bool" : return _impl.ta_is_initial_state(self, *args)
    def get_state_condition(self, *args) -> "bdd" : return _impl.ta_get_state_condition(self, *args)
    def free_state(self, *args) -> "void" : return _impl.ta_free_state(self, *args)
    def acc(self, *args) -> "spot::acc_cond &" : return _impl.ta_acc(self, *args)
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
    def succ_iter_by_changeset(self, *args) -> "spot::twa_succ_iterator *" : return _impl.tgta_succ_iter_by_changeset(self, *args)
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, *args): 
        _impl.ta_explicit_swiginit(self,_impl.new_ta_explicit(*args))
    def get_tgba(self) -> "spot::const_twa_ptr" : return _impl.ta_explicit_get_tgba(self)
    def add_state(self, *args) -> "spot::state_ta_explicit *" : return _impl.ta_explicit_add_state(self, *args)
    def add_to_initial_states_set(self, *args) -> "void" : return _impl.ta_explicit_add_to_initial_states_set(self, *args)
    def create_transition(self, *args) -> "void" : return _impl.ta_explicit_create_transition(self, *args)
    def delete_stuttering_transitions(self) -> "void" : return _impl.ta_explicit_delete_stuttering_transitions(self)
    __swig_destroy__ = _impl.delete_ta_explicit
    def succ_iter(self, *args) -> "spot::ta_succ_iterator *" : return _impl.ta_explicit_succ_iter(self, *args)
    def get_dict(self) -> "spot::bdd_dict_ptr" : return _impl.ta_explicit_get_dict(self)
    def get_artificial_initial_state(self) -> "spot::state *" : return _impl.ta_explicit_get_artificial_initial_state(self)
    def set_artificial_initial_state(self, *args) -> "void" : return _impl.ta_explicit_set_artificial_initial_state(self, *args)
    def delete_stuttering_and_hole_successors(self, *args) -> "void" : return _impl.ta_explicit_delete_stuttering_and_hole_successors(self, *args)
    def get_states_set(self) -> "spot::ta::states_set_t" : return _impl.ta_explicit_get_states_set(self)
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(*args) -> "spot::ta_explicit_ptr" :
  return _impl.make_ta_explicit(*args)
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, *args): 
        _impl.tgta_explicit_swiginit(self,_impl.new_tgta_explicit(*args))
    def get_init_state(self) -> "spot::state *" : return _impl.tgta_explicit_get_init_state(self)
    def get_ta(self, *args) -> "spot::ta_explicit_ptr" : return _impl.tgta_explicit_get_ta(self, *args)
    __swig_destroy__ = _impl.delete_tgta_explicit
tgta_explicit_swigregister = _impl.tgta_explicit_swigregister
tgta_explicit_swigregister(tgta_explicit)


def make_tgta_explicit(*args) -> "spot::tgta_explicit_ptr" :
  return _impl.make_tgta_explicit(*args)
make_tgta_explicit = _impl.make_tgta_explicit

def tgba_to_ta(*args) -> "spot::ta_explicit_ptr" :
  return _impl.tgba_to_ta(*args)
tgba_to_ta = _impl.tgba_to_ta

def tgba_to_tgta(*args) -> "spot::tgta_explicit_ptr" :
  return _impl.tgba_to_tgta(*args)
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 dump(self, *args) -> "std::ostream &" : return _impl.ta_statistics_dump(self, *args)
    def __init__(self): 
        _impl.ta_statistics_swiginit(self,_impl.new_ta_statistics())
    __swig_destroy__ = _impl.delete_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(*args) -> "spot::ta_explicit_ptr" :
  return _impl.minimize_ta(*args)
minimize_ta = _impl.minimize_ta

def minimize_tgta(*args) -> "spot::tgta_explicit_ptr" :
  return _impl.minimize_tgta(*args)
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, *args): 
        _impl.ofstream_swiginit(self,_impl.new_ofstream(*args))
    __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())
    def str(self) -> "std::string" : return _impl.ostringstream_str(self)
    __swig_destroy__ = _impl.delete_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(*args) -> "spot::twa_graph_ptr" :
  return _impl.ensure_digraph(*args)
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(*args) -> "void" :
  return _impl.print_on(*args)
print_on = _impl.print_on

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

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


