# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.3.0
#
# Do not make changes to this file unless you know what you are doing - modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _impl
else:
    import _impl

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

_swig_new_instance_method = _impl.SWIG_PyInstanceMethod_New
_swig_new_static_method = _impl.SWIG_PyStaticMethod_New

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


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


SHARED_PTR_DISOWN = _impl.SHARED_PTR_DISOWN
class SwigPyIterator_spot_impl(object):
    thisown = 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_spot_impl
    value = _swig_new_instance_method(_impl.SwigPyIterator_spot_impl_value)
    incr = _swig_new_instance_method(_impl.SwigPyIterator_spot_impl_incr)
    decr = _swig_new_instance_method(_impl.SwigPyIterator_spot_impl_decr)
    distance = _swig_new_instance_method(_impl.SwigPyIterator_spot_impl_distance)
    equal = _swig_new_instance_method(_impl.SwigPyIterator_spot_impl_equal)
    copy = _swig_new_instance_method(_impl.SwigPyIterator_spot_impl_copy)
    next = _swig_new_instance_method(_impl.SwigPyIterator_spot_impl_next)
    __next__ = _swig_new_instance_method(_impl.SwigPyIterator_spot_impl___next__)
    previous = _swig_new_instance_method(_impl.SwigPyIterator_spot_impl_previous)
    advance = _swig_new_instance_method(_impl.SwigPyIterator_spot_impl_advance)
    __eq__ = _swig_new_instance_method(_impl.SwigPyIterator_spot_impl___eq__)
    __ne__ = _swig_new_instance_method(_impl.SwigPyIterator_spot_impl___ne__)
    __iadd__ = _swig_new_instance_method(_impl.SwigPyIterator_spot_impl___iadd__)
    __isub__ = _swig_new_instance_method(_impl.SwigPyIterator_spot_impl___isub__)
    __add__ = _swig_new_instance_method(_impl.SwigPyIterator_spot_impl___add__)
    __sub__ = _swig_new_instance_method(_impl.SwigPyIterator_spot_impl___sub__)
    def __iter__(self):
        return self

# Register SwigPyIterator_spot_impl in _impl:
_impl.SwigPyIterator_spot_impl_swigregister(SwigPyIterator_spot_impl)
import buddy
class parse_error(Exception):
    r"""Exception thrown when a parse error is encountered."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, s):
        r"""Construct with error message *s*."""
        _impl.parse_error_swiginit(self, _impl.new_parse_error(s))
    __str__ = _swig_new_instance_method(_impl.parse_error___str__)
    __swig_destroy__ = _impl.delete_parse_error

# Register parse_error in _impl:
_impl.parse_error_swigregister(parse_error)
class parallel_policy(object):
    r"""
    This class is used to tell parallel algorithms what
    resources they may use.

    Currently, this simply stores an integer indicating the number
    of threads that the algorithm may create, but in the future it
    will probably do more.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, nthreads=1):
        r"""Construct with *nthreads* threads."""
        _impl.parallel_policy_swiginit(self, _impl.new_parallel_policy(nthreads))
    nthreads = _swig_new_instance_method(_impl.parallel_policy_nthreads)
    __swig_destroy__ = _impl.delete_parallel_policy

# Register parallel_policy in _impl:
_impl.parallel_policy_swigregister(parallel_policy)
version = _impl.version
class minato_isop(object):
    r"""
    Generate an irredundant sum-of-products (ISOP) form of a
    BDD function.

    This algorithm implements a derecursived version of the Minato-Morreale
    algorithm. 'minato.92.sasimi'
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        *Overload 1:*
        Constructor.
        * input The BDD function to translate in ISOP.

        |

        *Overload 2:*
        Constructor.
        * input The BDD function to translate in ISOP.
        * vars  The set of BDD variables to factorize in *input*.

        |

        *Overload 3:*
        Constructor.

        This version allows some flexibility in computing the ISOP.
        the result must be within *input_min* and *input_max*.
        * input_min The minimum BDD function to translate in ISOP.
        * input_max The maximum BDD function to translate in ISOP.
        """
        _impl.minato_isop_swiginit(self, _impl.new_minato_isop(*args))
    next = _swig_new_instance_method(_impl.minato_isop_next)
    __swig_destroy__ = _impl.delete_minato_isop

# Register minato_isop in _impl:
_impl.minato_isop_swigregister(minato_isop)
class option_map(object):
    r"""
    Manage a map of options.

    Each option is defined by a string and is associated to an integer value.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    parse_options = _swig_new_instance_method(_impl.option_map_parse_options)
    get = _swig_new_instance_method(_impl.option_map_get)
    get_str = _swig_new_instance_method(_impl.option_map_get_str)
    set_if_unset = _swig_new_instance_method(_impl.option_map_set_if_unset)
    set_str = _swig_new_instance_method(_impl.option_map_set_str)
    report_unused_options = _swig_new_instance_method(_impl.option_map_report_unused_options)
    set = _swig_new_instance_method(_impl.option_map_set)

    def __init__(self):
        _impl.option_map_swiginit(self, _impl.new_option_map())
    __swig_destroy__ = _impl.delete_option_map

# Register option_map in _impl:
_impl.option_map_swigregister(option_map)
srand = _impl.srand
rrand = _impl.rrand
mrand = _impl.mrand
drand = _impl.drand
nrand = _impl.nrand
escape_rfc4180 = _impl.escape_rfc4180
escape_latex = _impl.escape_latex
escape_html = _impl.escape_html
escape_str = _impl.escape_str
quote_shell_string = _impl.quote_shell_string
class trival(object):
    r"""
    A class implementing Kleene's three-valued logic.

    https://en.wikipedia.org/wiki/Three-valued_logic#Kleene_and_Priest_logics
    """

    thisown = 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):
        r"""
        *Overload 1:*
        Construct from a bool: false maps to no, true to yes.

        |

        *Overload 2:*
        Construct from a value_t enumerator.
        """
        _impl.trival_swiginit(self, _impl.new_trival(*args))
    maybe = _swig_new_static_method(_impl.trival_maybe)
    is_known = _swig_new_instance_method(_impl.trival_is_known)
    is_maybe = _swig_new_instance_method(_impl.trival_is_maybe)
    is_true = _swig_new_instance_method(_impl.trival_is_true)
    is_false = _swig_new_instance_method(_impl.trival_is_false)
    val = _swig_new_instance_method(_impl.trival_val)

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


    __repr__ = _swig_new_instance_method(_impl.trival___repr__)
    __str__ = _swig_new_instance_method(_impl.trival___str__)
    __neg__ = _swig_new_instance_method(_impl.trival___neg__)
    __and__ = _swig_new_instance_method(_impl.trival___and__)
    __or__ = _swig_new_instance_method(_impl.trival___or__)
    __eq__ = _swig_new_instance_method(_impl.trival___eq__)
    __ne__ = _swig_new_instance_method(_impl.trival___ne__)
    __swig_destroy__ = _impl.delete_trival

# Register trival in _impl:
_impl.trival_swigregister(trival)
op_ff = _impl.op_ff
r"""False"""
op_tt = _impl.op_tt
r"""True"""
op_eword = _impl.op_eword
r"""Empty word"""
op_ap = _impl.op_ap
r"""Atomic proposition"""
op_Not = _impl.op_Not
r"""Negation"""
op_X = _impl.op_X
r"""Next"""
op_F = _impl.op_F
r"""Eventually"""
op_G = _impl.op_G
r"""Globally"""
op_Closure = _impl.op_Closure
r"""PSL Closure"""
op_NegClosure = _impl.op_NegClosure
r"""Negated PSL Closure"""
op_NegClosureMarked = _impl.op_NegClosureMarked
r"""marked version of the Negated PSL Closure"""
op_Xor = _impl.op_Xor
r"""Exclusive Or"""
op_Implies = _impl.op_Implies
r"""Implication"""
op_Equiv = _impl.op_Equiv
r"""Equivalence"""
op_U = _impl.op_U
r"""until"""
op_R = _impl.op_R
r"""release (dual of until)"""
op_W = _impl.op_W
r"""weak until"""
op_M = _impl.op_M
r"""strong release (dual of weak until)"""
op_EConcat = _impl.op_EConcat
r"""Seq"""
op_EConcatMarked = _impl.op_EConcatMarked
r"""Seq, Marked"""
op_UConcat = _impl.op_UConcat
r"""Triggers"""
op_Or = _impl.op_Or
r"""(omega-Rational) Or"""
op_OrRat = _impl.op_OrRat
r"""Rational Or"""
op_And = _impl.op_And
r"""(omega-Rational) And"""
op_AndRat = _impl.op_AndRat
r"""Rational And"""
op_AndNLM = _impl.op_AndNLM
r"""Non-Length-Matching Rational-And"""
op_Concat = _impl.op_Concat
r"""Concatenation"""
op_Fusion = _impl.op_Fusion
r"""Fusion"""
op_Star = _impl.op_Star
r"""Star"""
op_FStar = _impl.op_FStar
r"""Fusion Star"""
op_first_match = _impl.op_first_match
r"""first_match(sere)"""
op_strong_X = _impl.op_strong_X
r"""strong Next"""
op_exists = _impl.op_exists
r"""existential quantification of AP"""
op_forall = _impl.op_forall
r"""universal quantification of AP"""
class formula(object):
    r"""Main class for temporal logic formula"""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        *Overload 1:*
        Create a formula from an fnode.

        This constructor is mainly for internal use, as fnode
        objects should usually not be manipulated from user code.

        |

        *Overload 2:*
        Create a null formula.

        This could be used to default-initialize a formula, however
        null formula should be short lived: most algorithms and member
        functions assume that formulas should not be null.

        |

        *Overload 3:*
        Default initialize a formula to None.

        |

        *Overload 4:*
        Clone a formula.

        |

        *Overload 5:*
        Move-construct a formula.
        """
        _impl.formula_swiginit(self, _impl.new_formula(*args))
    __swig_destroy__ = _impl.delete_formula
    __lt__ = _swig_new_instance_method(_impl.formula___lt__)
    __le__ = _swig_new_instance_method(_impl.formula___le__)
    __gt__ = _swig_new_instance_method(_impl.formula___gt__)
    __ge__ = _swig_new_instance_method(_impl.formula___ge__)
    __eq__ = _swig_new_instance_method(_impl.formula___eq__)
    __ne__ = _swig_new_instance_method(_impl.formula___ne__)

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


    apid_count = _swig_new_static_method(_impl.formula_apid_count)
    is_valid_apid = _swig_new_static_method(_impl.formula_is_valid_apid)
    apname_from_apid = _swig_new_static_method(_impl.formula_apname_from_apid)
    ap_from_apid = _swig_new_static_method(_impl.formula_ap_from_apid)
    apid_map = _swig_new_static_method(_impl.formula_apid_map)
    throw_if_quantified = _swig_new_instance_method(_impl.formula_throw_if_quantified)
    unbounded = _swig_new_static_method(_impl.formula_unbounded)
    ap = _swig_new_static_method(_impl.formula_ap)
    unop = _swig_new_static_method(_impl.formula_unop)
    Not = _swig_new_static_method(_impl.formula_Not)
    X = _swig_new_static_method(_impl.formula_X)
    strong_X = _swig_new_static_method(_impl.formula_strong_X)
    F = _swig_new_static_method(_impl.formula_F)
    G = _swig_new_static_method(_impl.formula_G)
    Closure = _swig_new_static_method(_impl.formula_Closure)
    NegClosure = _swig_new_static_method(_impl.formula_NegClosure)
    NegClosureMarked = _swig_new_static_method(_impl.formula_NegClosureMarked)
    first_match = _swig_new_static_method(_impl.formula_first_match)
    binop = _swig_new_static_method(_impl.formula_binop)
    Xor = _swig_new_static_method(_impl.formula_Xor)
    Implies = _swig_new_static_method(_impl.formula_Implies)
    Equiv = _swig_new_static_method(_impl.formula_Equiv)
    U = _swig_new_static_method(_impl.formula_U)
    R = _swig_new_static_method(_impl.formula_R)
    W = _swig_new_static_method(_impl.formula_W)
    M = _swig_new_static_method(_impl.formula_M)
    EConcat = _swig_new_static_method(_impl.formula_EConcat)
    EConcatMarked = _swig_new_static_method(_impl.formula_EConcatMarked)
    UConcat = _swig_new_static_method(_impl.formula_UConcat)
    multop = _swig_new_static_method(_impl.formula_multop)
    Or = _swig_new_static_method(_impl.formula_Or)
    OrRat = _swig_new_static_method(_impl.formula_OrRat)
    And = _swig_new_static_method(_impl.formula_And)
    AndRat = _swig_new_static_method(_impl.formula_AndRat)
    AndNLM = _swig_new_static_method(_impl.formula_AndNLM)
    Concat = _swig_new_static_method(_impl.formula_Concat)
    Fusion = _swig_new_static_method(_impl.formula_Fusion)
    bunop = _swig_new_static_method(_impl.formula_bunop)
    Star = _swig_new_static_method(_impl.formula_Star)
    FStar = _swig_new_static_method(_impl.formula_FStar)
    quantify = _swig_new_static_method(_impl.formula_quantify)
    exists = _swig_new_static_method(_impl.formula_exists)
    forall = _swig_new_static_method(_impl.formula_forall)
    nested_unop_range = _swig_new_static_method(_impl.formula_nested_unop_range)
    sugar_goto = _swig_new_static_method(_impl.formula_sugar_goto)
    sugar_equal = _swig_new_static_method(_impl.formula_sugar_equal)
    sugar_delay = _swig_new_static_method(_impl.formula_sugar_delay)
    kind = _swig_new_instance_method(_impl.formula_kind)
    kindstr = _swig_new_instance_method(_impl.formula_kindstr)
    _is = _swig_new_instance_method(_impl.formula__is)
    get_child_of = _swig_new_instance_method(_impl.formula_get_child_of)
    min = _swig_new_instance_method(_impl.formula_min)
    max = _swig_new_instance_method(_impl.formula_max)
    size = _swig_new_instance_method(_impl.formula_size)
    is_leaf = _swig_new_instance_method(_impl.formula_is_leaf)
    id = _swig_new_instance_method(_impl.formula_id)
    ff = _swig_new_static_method(_impl.formula_ff)
    is_ff = _swig_new_instance_method(_impl.formula_is_ff)
    tt = _swig_new_static_method(_impl.formula_tt)
    is_tt = _swig_new_instance_method(_impl.formula_is_tt)
    eword = _swig_new_static_method(_impl.formula_eword)
    is_eword = _swig_new_instance_method(_impl.formula_is_eword)
    is_constant = _swig_new_instance_method(_impl.formula_is_constant)
    is_Kleene_star = _swig_new_instance_method(_impl.formula_is_Kleene_star)
    one_star = _swig_new_static_method(_impl.formula_one_star)
    one_plus = _swig_new_static_method(_impl.formula_one_plus)
    is_literal = _swig_new_instance_method(_impl.formula_is_literal)
    ap_name = _swig_new_instance_method(_impl.formula_ap_name)
    apid = _swig_new_instance_method(_impl.formula_apid)
    dump = _swig_new_instance_method(_impl.formula_dump)
    all_but = _swig_new_instance_method(_impl.formula_all_but)
    boolean_count = _swig_new_instance_method(_impl.formula_boolean_count)
    boolean_operands = _swig_new_instance_method(_impl.formula_boolean_operands)
    is_boolean = _swig_new_instance_method(_impl.formula_is_boolean)
    is_sugar_free_boolean = _swig_new_instance_method(_impl.formula_is_sugar_free_boolean)
    is_in_nenoform = _swig_new_instance_method(_impl.formula_is_in_nenoform)
    is_syntactic_stutter_invariant = _swig_new_instance_method(_impl.formula_is_syntactic_stutter_invariant)
    is_sugar_free_ltl = _swig_new_instance_method(_impl.formula_is_sugar_free_ltl)
    is_ltl_formula = _swig_new_instance_method(_impl.formula_is_ltl_formula)
    is_psl_formula = _swig_new_instance_method(_impl.formula_is_psl_formula)
    is_sere_formula = _swig_new_instance_method(_impl.formula_is_sere_formula)
    is_finite = _swig_new_instance_method(_impl.formula_is_finite)
    is_eventual = _swig_new_instance_method(_impl.formula_is_eventual)
    is_universal = _swig_new_instance_method(_impl.formula_is_universal)
    is_syntactic_safety = _swig_new_instance_method(_impl.formula_is_syntactic_safety)
    is_syntactic_guarantee = _swig_new_instance_method(_impl.formula_is_syntactic_guarantee)
    is_delta1 = _swig_new_instance_method(_impl.formula_is_delta1)
    is_syntactic_obligation = _swig_new_instance_method(_impl.formula_is_syntactic_obligation)
    is_sigma2 = _swig_new_instance_method(_impl.formula_is_sigma2)
    is_pi2 = _swig_new_instance_method(_impl.formula_is_pi2)
    is_syntactic_recurrence = _swig_new_instance_method(_impl.formula_is_syntactic_recurrence)
    is_syntactic_persistence = _swig_new_instance_method(_impl.formula_is_syntactic_persistence)
    is_delta2 = _swig_new_instance_method(_impl.formula_is_delta2)
    is_marked = _swig_new_instance_method(_impl.formula_is_marked)
    accepts_eword = _swig_new_instance_method(_impl.formula_accepts_eword)
    has_lbt_atomic_props = _swig_new_instance_method(_impl.formula_has_lbt_atomic_props)
    has_spin_atomic_props = _swig_new_instance_method(_impl.formula_has_spin_atomic_props)
    is_quantified = _swig_new_instance_method(_impl.formula_is_quantified)
    __cmp__ = _swig_new_instance_method(_impl.formula___cmp__)
    __hash__ = _swig_new_instance_method(_impl.formula___hash__)
    __len__ = _swig_new_instance_method(_impl.formula___len__)
    __getitem__ = _swig_new_instance_method(_impl.formula___getitem__)
    __repr__ = _swig_new_instance_method(_impl.formula___repr__)
    __str__ = _swig_new_instance_method(_impl.formula___str__)

# Register formula in _impl:
_impl.formula_swigregister(formula)
print_formula_props = _impl.print_formula_props
list_formula_props = _impl.list_formula_props
class liststr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_impl.liststr_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_impl.liststr___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.liststr___bool__)
    __len__ = _swig_new_instance_method(_impl.liststr___len__)
    __getslice__ = _swig_new_instance_method(_impl.liststr___getslice__)
    __setslice__ = _swig_new_instance_method(_impl.liststr___setslice__)
    __delslice__ = _swig_new_instance_method(_impl.liststr___delslice__)
    __delitem__ = _swig_new_instance_method(_impl.liststr___delitem__)
    __getitem__ = _swig_new_instance_method(_impl.liststr___getitem__)
    __setitem__ = _swig_new_instance_method(_impl.liststr___setitem__)
    pop = _swig_new_instance_method(_impl.liststr_pop)
    append = _swig_new_instance_method(_impl.liststr_append)
    empty = _swig_new_instance_method(_impl.liststr_empty)
    size = _swig_new_instance_method(_impl.liststr_size)
    swap = _swig_new_instance_method(_impl.liststr_swap)
    begin = _swig_new_instance_method(_impl.liststr_begin)
    end = _swig_new_instance_method(_impl.liststr_end)
    rbegin = _swig_new_instance_method(_impl.liststr_rbegin)
    rend = _swig_new_instance_method(_impl.liststr_rend)
    clear = _swig_new_instance_method(_impl.liststr_clear)
    get_allocator = _swig_new_instance_method(_impl.liststr_get_allocator)
    pop_back = _swig_new_instance_method(_impl.liststr_pop_back)
    erase = _swig_new_instance_method(_impl.liststr_erase)

    def __init__(self, *args):
        _impl.liststr_swiginit(self, _impl.new_liststr(*args))
    push_back = _swig_new_instance_method(_impl.liststr_push_back)
    front = _swig_new_instance_method(_impl.liststr_front)
    back = _swig_new_instance_method(_impl.liststr_back)
    assign = _swig_new_instance_method(_impl.liststr_assign)
    resize = _swig_new_instance_method(_impl.liststr_resize)
    insert = _swig_new_instance_method(_impl.liststr_insert)
    pop_front = _swig_new_instance_method(_impl.liststr_pop_front)
    push_front = _swig_new_instance_method(_impl.liststr_push_front)
    reverse = _swig_new_instance_method(_impl.liststr_reverse)
    __swig_destroy__ = _impl.delete_liststr

# Register liststr in _impl:
_impl.liststr_swigregister(liststr)
class pairunsigned(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

# Register pairunsigned in _impl:
_impl.pairunsigned_swigregister(pairunsigned)
class pairmarkunsigned(object):
    thisown = 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.pairmarkunsigned_swiginit(self, _impl.new_pairmarkunsigned(*args))
    first = property(_impl.pairmarkunsigned_first_get, _impl.pairmarkunsigned_first_set)
    second = property(_impl.pairmarkunsigned_second_get, _impl.pairmarkunsigned_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_pairmarkunsigned

# Register pairmarkunsigned in _impl:
_impl.pairmarkunsigned_swigregister(pairmarkunsigned)
class pairmark_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

# Register pairmark_t in _impl:
_impl.pairmark_t_swigregister(pairmark_t)
class pairintacccode(object):
    thisown = 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.pairintacccode_swiginit(self, _impl.new_pairintacccode(*args))
    first = property(_impl.pairintacccode_first_get, _impl.pairintacccode_first_set)
    second = property(_impl.pairintacccode_second_get, _impl.pairintacccode_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_pairintacccode

# Register pairintacccode in _impl:
_impl.pairintacccode_swigregister(pairintacccode)
class pairintacccond(object):
    thisown = 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.pairintacccond_swiginit(self, _impl.new_pairintacccond(*args))
    first = property(_impl.pairintacccond_first_get, _impl.pairintacccond_first_set)
    second = property(_impl.pairintacccond_second_get, _impl.pairintacccond_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_pairintacccond

# Register pairintacccond in _impl:
_impl.pairintacccond_swigregister(pairintacccond)
class vectorformula(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    iterator = _swig_new_instance_method(_impl.vectorformula_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_impl.vectorformula___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.vectorformula___bool__)
    __len__ = _swig_new_instance_method(_impl.vectorformula___len__)
    __getslice__ = _swig_new_instance_method(_impl.vectorformula___getslice__)
    __setslice__ = _swig_new_instance_method(_impl.vectorformula___setslice__)
    __delslice__ = _swig_new_instance_method(_impl.vectorformula___delslice__)
    __delitem__ = _swig_new_instance_method(_impl.vectorformula___delitem__)
    __getitem__ = _swig_new_instance_method(_impl.vectorformula___getitem__)
    __setitem__ = _swig_new_instance_method(_impl.vectorformula___setitem__)
    pop = _swig_new_instance_method(_impl.vectorformula_pop)
    append = _swig_new_instance_method(_impl.vectorformula_append)
    empty = _swig_new_instance_method(_impl.vectorformula_empty)
    size = _swig_new_instance_method(_impl.vectorformula_size)
    swap = _swig_new_instance_method(_impl.vectorformula_swap)
    begin = _swig_new_instance_method(_impl.vectorformula_begin)
    end = _swig_new_instance_method(_impl.vectorformula_end)
    rbegin = _swig_new_instance_method(_impl.vectorformula_rbegin)
    rend = _swig_new_instance_method(_impl.vectorformula_rend)
    clear = _swig_new_instance_method(_impl.vectorformula_clear)
    get_allocator = _swig_new_instance_method(_impl.vectorformula_get_allocator)
    pop_back = _swig_new_instance_method(_impl.vectorformula_pop_back)
    erase = _swig_new_instance_method(_impl.vectorformula_erase)

    def __init__(self, *args):
        _impl.vectorformula_swiginit(self, _impl.new_vectorformula(*args))
    push_back = _swig_new_instance_method(_impl.vectorformula_push_back)
    front = _swig_new_instance_method(_impl.vectorformula_front)
    back = _swig_new_instance_method(_impl.vectorformula_back)
    assign = _swig_new_instance_method(_impl.vectorformula_assign)
    resize = _swig_new_instance_method(_impl.vectorformula_resize)
    insert = _swig_new_instance_method(_impl.vectorformula_insert)
    reserve = _swig_new_instance_method(_impl.vectorformula_reserve)
    capacity = _swig_new_instance_method(_impl.vectorformula_capacity)
    __str__ = _swig_new_instance_method(_impl.vectorformula___str__)
    __repr__ = _swig_new_instance_method(_impl.vectorformula___repr__)
    __swig_destroy__ = _impl.delete_vectorformula

# Register vectorformula in _impl:
_impl.vectorformula_swigregister(vectorformula)
class vectorcolors(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_impl.vectorcolors_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_impl.vectorcolors___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.vectorcolors___bool__)
    __len__ = _swig_new_instance_method(_impl.vectorcolors___len__)
    __getslice__ = _swig_new_instance_method(_impl.vectorcolors___getslice__)
    __setslice__ = _swig_new_instance_method(_impl.vectorcolors___setslice__)
    __delslice__ = _swig_new_instance_method(_impl.vectorcolors___delslice__)
    __delitem__ = _swig_new_instance_method(_impl.vectorcolors___delitem__)
    __getitem__ = _swig_new_instance_method(_impl.vectorcolors___getitem__)
    __setitem__ = _swig_new_instance_method(_impl.vectorcolors___setitem__)
    pop = _swig_new_instance_method(_impl.vectorcolors_pop)
    append = _swig_new_instance_method(_impl.vectorcolors_append)
    empty = _swig_new_instance_method(_impl.vectorcolors_empty)
    size = _swig_new_instance_method(_impl.vectorcolors_size)
    swap = _swig_new_instance_method(_impl.vectorcolors_swap)
    begin = _swig_new_instance_method(_impl.vectorcolors_begin)
    end = _swig_new_instance_method(_impl.vectorcolors_end)
    rbegin = _swig_new_instance_method(_impl.vectorcolors_rbegin)
    rend = _swig_new_instance_method(_impl.vectorcolors_rend)
    clear = _swig_new_instance_method(_impl.vectorcolors_clear)
    get_allocator = _swig_new_instance_method(_impl.vectorcolors_get_allocator)
    pop_back = _swig_new_instance_method(_impl.vectorcolors_pop_back)
    erase = _swig_new_instance_method(_impl.vectorcolors_erase)

    def __init__(self, *args):
        _impl.vectorcolors_swiginit(self, _impl.new_vectorcolors(*args))
    push_back = _swig_new_instance_method(_impl.vectorcolors_push_back)
    front = _swig_new_instance_method(_impl.vectorcolors_front)
    back = _swig_new_instance_method(_impl.vectorcolors_back)
    assign = _swig_new_instance_method(_impl.vectorcolors_assign)
    resize = _swig_new_instance_method(_impl.vectorcolors_resize)
    insert = _swig_new_instance_method(_impl.vectorcolors_insert)
    reserve = _swig_new_instance_method(_impl.vectorcolors_reserve)
    capacity = _swig_new_instance_method(_impl.vectorcolors_capacity)
    __swig_destroy__ = _impl.delete_vectorcolors

# Register vectorcolors in _impl:
_impl.vectorcolors_swigregister(vectorcolors)
class vectorunsigned(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_impl.vectorunsigned_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_impl.vectorunsigned___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.vectorunsigned___bool__)
    __len__ = _swig_new_instance_method(_impl.vectorunsigned___len__)
    __getslice__ = _swig_new_instance_method(_impl.vectorunsigned___getslice__)
    __setslice__ = _swig_new_instance_method(_impl.vectorunsigned___setslice__)
    __delslice__ = _swig_new_instance_method(_impl.vectorunsigned___delslice__)
    __delitem__ = _swig_new_instance_method(_impl.vectorunsigned___delitem__)
    __getitem__ = _swig_new_instance_method(_impl.vectorunsigned___getitem__)
    __setitem__ = _swig_new_instance_method(_impl.vectorunsigned___setitem__)
    pop = _swig_new_instance_method(_impl.vectorunsigned_pop)
    append = _swig_new_instance_method(_impl.vectorunsigned_append)
    empty = _swig_new_instance_method(_impl.vectorunsigned_empty)
    size = _swig_new_instance_method(_impl.vectorunsigned_size)
    swap = _swig_new_instance_method(_impl.vectorunsigned_swap)
    begin = _swig_new_instance_method(_impl.vectorunsigned_begin)
    end = _swig_new_instance_method(_impl.vectorunsigned_end)
    rbegin = _swig_new_instance_method(_impl.vectorunsigned_rbegin)
    rend = _swig_new_instance_method(_impl.vectorunsigned_rend)
    clear = _swig_new_instance_method(_impl.vectorunsigned_clear)
    get_allocator = _swig_new_instance_method(_impl.vectorunsigned_get_allocator)
    pop_back = _swig_new_instance_method(_impl.vectorunsigned_pop_back)
    erase = _swig_new_instance_method(_impl.vectorunsigned_erase)

    def __init__(self, *args):
        _impl.vectorunsigned_swiginit(self, _impl.new_vectorunsigned(*args))
    push_back = _swig_new_instance_method(_impl.vectorunsigned_push_back)
    front = _swig_new_instance_method(_impl.vectorunsigned_front)
    back = _swig_new_instance_method(_impl.vectorunsigned_back)
    assign = _swig_new_instance_method(_impl.vectorunsigned_assign)
    resize = _swig_new_instance_method(_impl.vectorunsigned_resize)
    insert = _swig_new_instance_method(_impl.vectorunsigned_insert)
    reserve = _swig_new_instance_method(_impl.vectorunsigned_reserve)
    capacity = _swig_new_instance_method(_impl.vectorunsigned_capacity)
    __swig_destroy__ = _impl.delete_vectorunsigned

# Register vectorunsigned in _impl:
_impl.vectorunsigned_swigregister(vectorunsigned)
class vectorunsignedchar(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_impl.vectorunsignedchar_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_impl.vectorunsignedchar___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.vectorunsignedchar___bool__)
    __len__ = _swig_new_instance_method(_impl.vectorunsignedchar___len__)
    __getslice__ = _swig_new_instance_method(_impl.vectorunsignedchar___getslice__)
    __setslice__ = _swig_new_instance_method(_impl.vectorunsignedchar___setslice__)
    __delslice__ = _swig_new_instance_method(_impl.vectorunsignedchar___delslice__)
    __delitem__ = _swig_new_instance_method(_impl.vectorunsignedchar___delitem__)
    __getitem__ = _swig_new_instance_method(_impl.vectorunsignedchar___getitem__)
    __setitem__ = _swig_new_instance_method(_impl.vectorunsignedchar___setitem__)
    pop = _swig_new_instance_method(_impl.vectorunsignedchar_pop)
    append = _swig_new_instance_method(_impl.vectorunsignedchar_append)
    empty = _swig_new_instance_method(_impl.vectorunsignedchar_empty)
    size = _swig_new_instance_method(_impl.vectorunsignedchar_size)
    swap = _swig_new_instance_method(_impl.vectorunsignedchar_swap)
    begin = _swig_new_instance_method(_impl.vectorunsignedchar_begin)
    end = _swig_new_instance_method(_impl.vectorunsignedchar_end)
    rbegin = _swig_new_instance_method(_impl.vectorunsignedchar_rbegin)
    rend = _swig_new_instance_method(_impl.vectorunsignedchar_rend)
    clear = _swig_new_instance_method(_impl.vectorunsignedchar_clear)
    get_allocator = _swig_new_instance_method(_impl.vectorunsignedchar_get_allocator)
    pop_back = _swig_new_instance_method(_impl.vectorunsignedchar_pop_back)
    erase = _swig_new_instance_method(_impl.vectorunsignedchar_erase)

    def __init__(self, *args):
        _impl.vectorunsignedchar_swiginit(self, _impl.new_vectorunsignedchar(*args))
    push_back = _swig_new_instance_method(_impl.vectorunsignedchar_push_back)
    front = _swig_new_instance_method(_impl.vectorunsignedchar_front)
    back = _swig_new_instance_method(_impl.vectorunsignedchar_back)
    assign = _swig_new_instance_method(_impl.vectorunsignedchar_assign)
    resize = _swig_new_instance_method(_impl.vectorunsignedchar_resize)
    insert = _swig_new_instance_method(_impl.vectorunsignedchar_insert)
    reserve = _swig_new_instance_method(_impl.vectorunsignedchar_reserve)
    capacity = _swig_new_instance_method(_impl.vectorunsignedchar_capacity)
    __swig_destroy__ = _impl.delete_vectorunsignedchar

# Register vectorunsignedchar in _impl:
_impl.vectorunsignedchar_swigregister(vectorunsignedchar)
class vectorvectorunsigned(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_impl.vectorvectorunsigned_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_impl.vectorvectorunsigned___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.vectorvectorunsigned___bool__)
    __len__ = _swig_new_instance_method(_impl.vectorvectorunsigned___len__)
    __getslice__ = _swig_new_instance_method(_impl.vectorvectorunsigned___getslice__)
    __setslice__ = _swig_new_instance_method(_impl.vectorvectorunsigned___setslice__)
    __delslice__ = _swig_new_instance_method(_impl.vectorvectorunsigned___delslice__)
    __delitem__ = _swig_new_instance_method(_impl.vectorvectorunsigned___delitem__)
    __getitem__ = _swig_new_instance_method(_impl.vectorvectorunsigned___getitem__)
    __setitem__ = _swig_new_instance_method(_impl.vectorvectorunsigned___setitem__)
    pop = _swig_new_instance_method(_impl.vectorvectorunsigned_pop)
    append = _swig_new_instance_method(_impl.vectorvectorunsigned_append)
    empty = _swig_new_instance_method(_impl.vectorvectorunsigned_empty)
    size = _swig_new_instance_method(_impl.vectorvectorunsigned_size)
    swap = _swig_new_instance_method(_impl.vectorvectorunsigned_swap)
    begin = _swig_new_instance_method(_impl.vectorvectorunsigned_begin)
    end = _swig_new_instance_method(_impl.vectorvectorunsigned_end)
    rbegin = _swig_new_instance_method(_impl.vectorvectorunsigned_rbegin)
    rend = _swig_new_instance_method(_impl.vectorvectorunsigned_rend)
    clear = _swig_new_instance_method(_impl.vectorvectorunsigned_clear)
    get_allocator = _swig_new_instance_method(_impl.vectorvectorunsigned_get_allocator)
    pop_back = _swig_new_instance_method(_impl.vectorvectorunsigned_pop_back)
    erase = _swig_new_instance_method(_impl.vectorvectorunsigned_erase)

    def __init__(self, *args):
        _impl.vectorvectorunsigned_swiginit(self, _impl.new_vectorvectorunsigned(*args))
    push_back = _swig_new_instance_method(_impl.vectorvectorunsigned_push_back)
    front = _swig_new_instance_method(_impl.vectorvectorunsigned_front)
    back = _swig_new_instance_method(_impl.vectorvectorunsigned_back)
    assign = _swig_new_instance_method(_impl.vectorvectorunsigned_assign)
    resize = _swig_new_instance_method(_impl.vectorvectorunsigned_resize)
    insert = _swig_new_instance_method(_impl.vectorvectorunsigned_insert)
    reserve = _swig_new_instance_method(_impl.vectorvectorunsigned_reserve)
    capacity = _swig_new_instance_method(_impl.vectorvectorunsigned_capacity)
    __swig_destroy__ = _impl.delete_vectorvectorunsigned

# Register vectorvectorunsigned in _impl:
_impl.vectorvectorunsigned_swigregister(vectorvectorunsigned)
class vectorvectorint(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_impl.vectorvectorint_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_impl.vectorvectorint___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.vectorvectorint___bool__)
    __len__ = _swig_new_instance_method(_impl.vectorvectorint___len__)
    __getslice__ = _swig_new_instance_method(_impl.vectorvectorint___getslice__)
    __setslice__ = _swig_new_instance_method(_impl.vectorvectorint___setslice__)
    __delslice__ = _swig_new_instance_method(_impl.vectorvectorint___delslice__)
    __delitem__ = _swig_new_instance_method(_impl.vectorvectorint___delitem__)
    __getitem__ = _swig_new_instance_method(_impl.vectorvectorint___getitem__)
    __setitem__ = _swig_new_instance_method(_impl.vectorvectorint___setitem__)
    pop = _swig_new_instance_method(_impl.vectorvectorint_pop)
    append = _swig_new_instance_method(_impl.vectorvectorint_append)
    empty = _swig_new_instance_method(_impl.vectorvectorint_empty)
    size = _swig_new_instance_method(_impl.vectorvectorint_size)
    swap = _swig_new_instance_method(_impl.vectorvectorint_swap)
    begin = _swig_new_instance_method(_impl.vectorvectorint_begin)
    end = _swig_new_instance_method(_impl.vectorvectorint_end)
    rbegin = _swig_new_instance_method(_impl.vectorvectorint_rbegin)
    rend = _swig_new_instance_method(_impl.vectorvectorint_rend)
    clear = _swig_new_instance_method(_impl.vectorvectorint_clear)
    get_allocator = _swig_new_instance_method(_impl.vectorvectorint_get_allocator)
    pop_back = _swig_new_instance_method(_impl.vectorvectorint_pop_back)
    erase = _swig_new_instance_method(_impl.vectorvectorint_erase)

    def __init__(self, *args):
        _impl.vectorvectorint_swiginit(self, _impl.new_vectorvectorint(*args))
    push_back = _swig_new_instance_method(_impl.vectorvectorint_push_back)
    front = _swig_new_instance_method(_impl.vectorvectorint_front)
    back = _swig_new_instance_method(_impl.vectorvectorint_back)
    assign = _swig_new_instance_method(_impl.vectorvectorint_assign)
    resize = _swig_new_instance_method(_impl.vectorvectorint_resize)
    insert = _swig_new_instance_method(_impl.vectorvectorint_insert)
    reserve = _swig_new_instance_method(_impl.vectorvectorint_reserve)
    capacity = _swig_new_instance_method(_impl.vectorvectorint_capacity)
    __swig_destroy__ = _impl.delete_vectorvectorint

# Register vectorvectorint in _impl:
_impl.vectorvectorint_swigregister(vectorvectorint)
class vectorpairunsigned(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_impl.vectorpairunsigned_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_impl.vectorpairunsigned___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.vectorpairunsigned___bool__)
    __len__ = _swig_new_instance_method(_impl.vectorpairunsigned___len__)
    __getslice__ = _swig_new_instance_method(_impl.vectorpairunsigned___getslice__)
    __setslice__ = _swig_new_instance_method(_impl.vectorpairunsigned___setslice__)
    __delslice__ = _swig_new_instance_method(_impl.vectorpairunsigned___delslice__)
    __delitem__ = _swig_new_instance_method(_impl.vectorpairunsigned___delitem__)
    __getitem__ = _swig_new_instance_method(_impl.vectorpairunsigned___getitem__)
    __setitem__ = _swig_new_instance_method(_impl.vectorpairunsigned___setitem__)
    pop = _swig_new_instance_method(_impl.vectorpairunsigned_pop)
    append = _swig_new_instance_method(_impl.vectorpairunsigned_append)
    empty = _swig_new_instance_method(_impl.vectorpairunsigned_empty)
    size = _swig_new_instance_method(_impl.vectorpairunsigned_size)
    swap = _swig_new_instance_method(_impl.vectorpairunsigned_swap)
    begin = _swig_new_instance_method(_impl.vectorpairunsigned_begin)
    end = _swig_new_instance_method(_impl.vectorpairunsigned_end)
    rbegin = _swig_new_instance_method(_impl.vectorpairunsigned_rbegin)
    rend = _swig_new_instance_method(_impl.vectorpairunsigned_rend)
    clear = _swig_new_instance_method(_impl.vectorpairunsigned_clear)
    get_allocator = _swig_new_instance_method(_impl.vectorpairunsigned_get_allocator)
    pop_back = _swig_new_instance_method(_impl.vectorpairunsigned_pop_back)
    erase = _swig_new_instance_method(_impl.vectorpairunsigned_erase)

    def __init__(self, *args):
        _impl.vectorpairunsigned_swiginit(self, _impl.new_vectorpairunsigned(*args))
    push_back = _swig_new_instance_method(_impl.vectorpairunsigned_push_back)
    front = _swig_new_instance_method(_impl.vectorpairunsigned_front)
    back = _swig_new_instance_method(_impl.vectorpairunsigned_back)
    assign = _swig_new_instance_method(_impl.vectorpairunsigned_assign)
    resize = _swig_new_instance_method(_impl.vectorpairunsigned_resize)
    insert = _swig_new_instance_method(_impl.vectorpairunsigned_insert)
    reserve = _swig_new_instance_method(_impl.vectorpairunsigned_reserve)
    capacity = _swig_new_instance_method(_impl.vectorpairunsigned_capacity)
    __swig_destroy__ = _impl.delete_vectorpairunsigned

# Register vectorpairunsigned in _impl:
_impl.vectorpairunsigned_swigregister(vectorpairunsigned)
class vectoracccond(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_impl.vectoracccond_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_impl.vectoracccond___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.vectoracccond___bool__)
    __len__ = _swig_new_instance_method(_impl.vectoracccond___len__)
    __getslice__ = _swig_new_instance_method(_impl.vectoracccond___getslice__)
    __setslice__ = _swig_new_instance_method(_impl.vectoracccond___setslice__)
    __delslice__ = _swig_new_instance_method(_impl.vectoracccond___delslice__)
    __delitem__ = _swig_new_instance_method(_impl.vectoracccond___delitem__)
    __getitem__ = _swig_new_instance_method(_impl.vectoracccond___getitem__)
    __setitem__ = _swig_new_instance_method(_impl.vectoracccond___setitem__)
    pop = _swig_new_instance_method(_impl.vectoracccond_pop)
    append = _swig_new_instance_method(_impl.vectoracccond_append)
    empty = _swig_new_instance_method(_impl.vectoracccond_empty)
    size = _swig_new_instance_method(_impl.vectoracccond_size)
    swap = _swig_new_instance_method(_impl.vectoracccond_swap)
    begin = _swig_new_instance_method(_impl.vectoracccond_begin)
    end = _swig_new_instance_method(_impl.vectoracccond_end)
    rbegin = _swig_new_instance_method(_impl.vectoracccond_rbegin)
    rend = _swig_new_instance_method(_impl.vectoracccond_rend)
    clear = _swig_new_instance_method(_impl.vectoracccond_clear)
    get_allocator = _swig_new_instance_method(_impl.vectoracccond_get_allocator)
    pop_back = _swig_new_instance_method(_impl.vectoracccond_pop_back)
    erase = _swig_new_instance_method(_impl.vectoracccond_erase)

    def __init__(self, *args):
        _impl.vectoracccond_swiginit(self, _impl.new_vectoracccond(*args))
    push_back = _swig_new_instance_method(_impl.vectoracccond_push_back)
    front = _swig_new_instance_method(_impl.vectoracccond_front)
    back = _swig_new_instance_method(_impl.vectoracccond_back)
    assign = _swig_new_instance_method(_impl.vectoracccond_assign)
    resize = _swig_new_instance_method(_impl.vectoracccond_resize)
    insert = _swig_new_instance_method(_impl.vectoracccond_insert)
    reserve = _swig_new_instance_method(_impl.vectoracccond_reserve)
    capacity = _swig_new_instance_method(_impl.vectoracccond_capacity)
    __swig_destroy__ = _impl.delete_vectoracccond

# Register vectoracccond in _impl:
_impl.vectoracccond_swigregister(vectoracccond)
class vectoracccode(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_impl.vectoracccode_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_impl.vectoracccode___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.vectoracccode___bool__)
    __len__ = _swig_new_instance_method(_impl.vectoracccode___len__)
    __getslice__ = _swig_new_instance_method(_impl.vectoracccode___getslice__)
    __setslice__ = _swig_new_instance_method(_impl.vectoracccode___setslice__)
    __delslice__ = _swig_new_instance_method(_impl.vectoracccode___delslice__)
    __delitem__ = _swig_new_instance_method(_impl.vectoracccode___delitem__)
    __getitem__ = _swig_new_instance_method(_impl.vectoracccode___getitem__)
    __setitem__ = _swig_new_instance_method(_impl.vectoracccode___setitem__)
    pop = _swig_new_instance_method(_impl.vectoracccode_pop)
    append = _swig_new_instance_method(_impl.vectoracccode_append)
    empty = _swig_new_instance_method(_impl.vectoracccode_empty)
    size = _swig_new_instance_method(_impl.vectoracccode_size)
    swap = _swig_new_instance_method(_impl.vectoracccode_swap)
    begin = _swig_new_instance_method(_impl.vectoracccode_begin)
    end = _swig_new_instance_method(_impl.vectoracccode_end)
    rbegin = _swig_new_instance_method(_impl.vectoracccode_rbegin)
    rend = _swig_new_instance_method(_impl.vectoracccode_rend)
    clear = _swig_new_instance_method(_impl.vectoracccode_clear)
    get_allocator = _swig_new_instance_method(_impl.vectoracccode_get_allocator)
    pop_back = _swig_new_instance_method(_impl.vectoracccode_pop_back)
    erase = _swig_new_instance_method(_impl.vectoracccode_erase)

    def __init__(self, *args):
        _impl.vectoracccode_swiginit(self, _impl.new_vectoracccode(*args))
    push_back = _swig_new_instance_method(_impl.vectoracccode_push_back)
    front = _swig_new_instance_method(_impl.vectoracccode_front)
    back = _swig_new_instance_method(_impl.vectoracccode_back)
    assign = _swig_new_instance_method(_impl.vectoracccode_assign)
    resize = _swig_new_instance_method(_impl.vectoracccode_resize)
    insert = _swig_new_instance_method(_impl.vectoracccode_insert)
    reserve = _swig_new_instance_method(_impl.vectoracccode_reserve)
    capacity = _swig_new_instance_method(_impl.vectoracccode_capacity)
    __swig_destroy__ = _impl.delete_vectoracccode

# Register vectoracccode in _impl:
_impl.vectoracccode_swigregister(vectoracccode)
class vectormarkunsigned(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_impl.vectormarkunsigned_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_impl.vectormarkunsigned___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.vectormarkunsigned___bool__)
    __len__ = _swig_new_instance_method(_impl.vectormarkunsigned___len__)
    __getslice__ = _swig_new_instance_method(_impl.vectormarkunsigned___getslice__)
    __setslice__ = _swig_new_instance_method(_impl.vectormarkunsigned___setslice__)
    __delslice__ = _swig_new_instance_method(_impl.vectormarkunsigned___delslice__)
    __delitem__ = _swig_new_instance_method(_impl.vectormarkunsigned___delitem__)
    __getitem__ = _swig_new_instance_method(_impl.vectormarkunsigned___getitem__)
    __setitem__ = _swig_new_instance_method(_impl.vectormarkunsigned___setitem__)
    pop = _swig_new_instance_method(_impl.vectormarkunsigned_pop)
    append = _swig_new_instance_method(_impl.vectormarkunsigned_append)
    empty = _swig_new_instance_method(_impl.vectormarkunsigned_empty)
    size = _swig_new_instance_method(_impl.vectormarkunsigned_size)
    swap = _swig_new_instance_method(_impl.vectormarkunsigned_swap)
    begin = _swig_new_instance_method(_impl.vectormarkunsigned_begin)
    end = _swig_new_instance_method(_impl.vectormarkunsigned_end)
    rbegin = _swig_new_instance_method(_impl.vectormarkunsigned_rbegin)
    rend = _swig_new_instance_method(_impl.vectormarkunsigned_rend)
    clear = _swig_new_instance_method(_impl.vectormarkunsigned_clear)
    get_allocator = _swig_new_instance_method(_impl.vectormarkunsigned_get_allocator)
    pop_back = _swig_new_instance_method(_impl.vectormarkunsigned_pop_back)
    erase = _swig_new_instance_method(_impl.vectormarkunsigned_erase)

    def __init__(self, *args):
        _impl.vectormarkunsigned_swiginit(self, _impl.new_vectormarkunsigned(*args))
    push_back = _swig_new_instance_method(_impl.vectormarkunsigned_push_back)
    front = _swig_new_instance_method(_impl.vectormarkunsigned_front)
    back = _swig_new_instance_method(_impl.vectormarkunsigned_back)
    assign = _swig_new_instance_method(_impl.vectormarkunsigned_assign)
    resize = _swig_new_instance_method(_impl.vectormarkunsigned_resize)
    insert = _swig_new_instance_method(_impl.vectormarkunsigned_insert)
    reserve = _swig_new_instance_method(_impl.vectormarkunsigned_reserve)
    capacity = _swig_new_instance_method(_impl.vectormarkunsigned_capacity)
    __swig_destroy__ = _impl.delete_vectormarkunsigned

# Register vectormarkunsigned in _impl:
_impl.vectormarkunsigned_swigregister(vectormarkunsigned)
class vectorbool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_impl.vectorbool_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_impl.vectorbool___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.vectorbool___bool__)
    __len__ = _swig_new_instance_method(_impl.vectorbool___len__)
    __getslice__ = _swig_new_instance_method(_impl.vectorbool___getslice__)
    __setslice__ = _swig_new_instance_method(_impl.vectorbool___setslice__)
    __delslice__ = _swig_new_instance_method(_impl.vectorbool___delslice__)
    __delitem__ = _swig_new_instance_method(_impl.vectorbool___delitem__)
    __getitem__ = _swig_new_instance_method(_impl.vectorbool___getitem__)
    __setitem__ = _swig_new_instance_method(_impl.vectorbool___setitem__)
    pop = _swig_new_instance_method(_impl.vectorbool_pop)
    append = _swig_new_instance_method(_impl.vectorbool_append)
    empty = _swig_new_instance_method(_impl.vectorbool_empty)
    size = _swig_new_instance_method(_impl.vectorbool_size)
    swap = _swig_new_instance_method(_impl.vectorbool_swap)
    begin = _swig_new_instance_method(_impl.vectorbool_begin)
    end = _swig_new_instance_method(_impl.vectorbool_end)
    rbegin = _swig_new_instance_method(_impl.vectorbool_rbegin)
    rend = _swig_new_instance_method(_impl.vectorbool_rend)
    clear = _swig_new_instance_method(_impl.vectorbool_clear)
    get_allocator = _swig_new_instance_method(_impl.vectorbool_get_allocator)
    pop_back = _swig_new_instance_method(_impl.vectorbool_pop_back)
    erase = _swig_new_instance_method(_impl.vectorbool_erase)

    def __init__(self, *args):
        _impl.vectorbool_swiginit(self, _impl.new_vectorbool(*args))
    push_back = _swig_new_instance_method(_impl.vectorbool_push_back)
    front = _swig_new_instance_method(_impl.vectorbool_front)
    back = _swig_new_instance_method(_impl.vectorbool_back)
    assign = _swig_new_instance_method(_impl.vectorbool_assign)
    resize = _swig_new_instance_method(_impl.vectorbool_resize)
    insert = _swig_new_instance_method(_impl.vectorbool_insert)
    reserve = _swig_new_instance_method(_impl.vectorbool_reserve)
    capacity = _swig_new_instance_method(_impl.vectorbool_capacity)
    __swig_destroy__ = _impl.delete_vectorbool

# Register vectorbool in _impl:
_impl.vectorbool_swigregister(vectorbool)
class vectorbdd(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_impl.vectorbdd_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_impl.vectorbdd___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.vectorbdd___bool__)
    __len__ = _swig_new_instance_method(_impl.vectorbdd___len__)
    __getslice__ = _swig_new_instance_method(_impl.vectorbdd___getslice__)
    __setslice__ = _swig_new_instance_method(_impl.vectorbdd___setslice__)
    __delslice__ = _swig_new_instance_method(_impl.vectorbdd___delslice__)
    __delitem__ = _swig_new_instance_method(_impl.vectorbdd___delitem__)
    __getitem__ = _swig_new_instance_method(_impl.vectorbdd___getitem__)
    __setitem__ = _swig_new_instance_method(_impl.vectorbdd___setitem__)
    pop = _swig_new_instance_method(_impl.vectorbdd_pop)
    append = _swig_new_instance_method(_impl.vectorbdd_append)
    empty = _swig_new_instance_method(_impl.vectorbdd_empty)
    size = _swig_new_instance_method(_impl.vectorbdd_size)
    swap = _swig_new_instance_method(_impl.vectorbdd_swap)
    begin = _swig_new_instance_method(_impl.vectorbdd_begin)
    end = _swig_new_instance_method(_impl.vectorbdd_end)
    rbegin = _swig_new_instance_method(_impl.vectorbdd_rbegin)
    rend = _swig_new_instance_method(_impl.vectorbdd_rend)
    clear = _swig_new_instance_method(_impl.vectorbdd_clear)
    get_allocator = _swig_new_instance_method(_impl.vectorbdd_get_allocator)
    pop_back = _swig_new_instance_method(_impl.vectorbdd_pop_back)
    erase = _swig_new_instance_method(_impl.vectorbdd_erase)

    def __init__(self, *args):
        _impl.vectorbdd_swiginit(self, _impl.new_vectorbdd(*args))
    push_back = _swig_new_instance_method(_impl.vectorbdd_push_back)
    front = _swig_new_instance_method(_impl.vectorbdd_front)
    back = _swig_new_instance_method(_impl.vectorbdd_back)
    assign = _swig_new_instance_method(_impl.vectorbdd_assign)
    resize = _swig_new_instance_method(_impl.vectorbdd_resize)
    insert = _swig_new_instance_method(_impl.vectorbdd_insert)
    reserve = _swig_new_instance_method(_impl.vectorbdd_reserve)
    capacity = _swig_new_instance_method(_impl.vectorbdd_capacity)
    __swig_destroy__ = _impl.delete_vectorbdd

# Register vectorbdd in _impl:
_impl.vectorbdd_swigregister(vectorbdd)
class vectortrival(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_impl.vectortrival_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_impl.vectortrival___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.vectortrival___bool__)
    __len__ = _swig_new_instance_method(_impl.vectortrival___len__)
    __getslice__ = _swig_new_instance_method(_impl.vectortrival___getslice__)
    __setslice__ = _swig_new_instance_method(_impl.vectortrival___setslice__)
    __delslice__ = _swig_new_instance_method(_impl.vectortrival___delslice__)
    __delitem__ = _swig_new_instance_method(_impl.vectortrival___delitem__)
    __getitem__ = _swig_new_instance_method(_impl.vectortrival___getitem__)
    __setitem__ = _swig_new_instance_method(_impl.vectortrival___setitem__)
    pop = _swig_new_instance_method(_impl.vectortrival_pop)
    append = _swig_new_instance_method(_impl.vectortrival_append)
    empty = _swig_new_instance_method(_impl.vectortrival_empty)
    size = _swig_new_instance_method(_impl.vectortrival_size)
    swap = _swig_new_instance_method(_impl.vectortrival_swap)
    begin = _swig_new_instance_method(_impl.vectortrival_begin)
    end = _swig_new_instance_method(_impl.vectortrival_end)
    rbegin = _swig_new_instance_method(_impl.vectortrival_rbegin)
    rend = _swig_new_instance_method(_impl.vectortrival_rend)
    clear = _swig_new_instance_method(_impl.vectortrival_clear)
    get_allocator = _swig_new_instance_method(_impl.vectortrival_get_allocator)
    pop_back = _swig_new_instance_method(_impl.vectortrival_pop_back)
    erase = _swig_new_instance_method(_impl.vectortrival_erase)

    def __init__(self, *args):
        _impl.vectortrival_swiginit(self, _impl.new_vectortrival(*args))
    push_back = _swig_new_instance_method(_impl.vectortrival_push_back)
    front = _swig_new_instance_method(_impl.vectortrival_front)
    back = _swig_new_instance_method(_impl.vectortrival_back)
    assign = _swig_new_instance_method(_impl.vectortrival_assign)
    resize = _swig_new_instance_method(_impl.vectortrival_resize)
    insert = _swig_new_instance_method(_impl.vectortrival_insert)
    reserve = _swig_new_instance_method(_impl.vectortrival_reserve)
    capacity = _swig_new_instance_method(_impl.vectortrival_capacity)
    __swig_destroy__ = _impl.delete_vectortrival

# Register vectortrival in _impl:
_impl.vectortrival_swigregister(vectortrival)
class aliasvector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_impl.aliasvector_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_impl.aliasvector___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.aliasvector___bool__)
    __len__ = _swig_new_instance_method(_impl.aliasvector___len__)
    __getslice__ = _swig_new_instance_method(_impl.aliasvector___getslice__)
    __setslice__ = _swig_new_instance_method(_impl.aliasvector___setslice__)
    __delslice__ = _swig_new_instance_method(_impl.aliasvector___delslice__)
    __delitem__ = _swig_new_instance_method(_impl.aliasvector___delitem__)
    __getitem__ = _swig_new_instance_method(_impl.aliasvector___getitem__)
    __setitem__ = _swig_new_instance_method(_impl.aliasvector___setitem__)
    pop = _swig_new_instance_method(_impl.aliasvector_pop)
    append = _swig_new_instance_method(_impl.aliasvector_append)
    empty = _swig_new_instance_method(_impl.aliasvector_empty)
    size = _swig_new_instance_method(_impl.aliasvector_size)
    swap = _swig_new_instance_method(_impl.aliasvector_swap)
    begin = _swig_new_instance_method(_impl.aliasvector_begin)
    end = _swig_new_instance_method(_impl.aliasvector_end)
    rbegin = _swig_new_instance_method(_impl.aliasvector_rbegin)
    rend = _swig_new_instance_method(_impl.aliasvector_rend)
    clear = _swig_new_instance_method(_impl.aliasvector_clear)
    get_allocator = _swig_new_instance_method(_impl.aliasvector_get_allocator)
    pop_back = _swig_new_instance_method(_impl.aliasvector_pop_back)
    erase = _swig_new_instance_method(_impl.aliasvector_erase)

    def __init__(self, *args):
        _impl.aliasvector_swiginit(self, _impl.new_aliasvector(*args))
    push_back = _swig_new_instance_method(_impl.aliasvector_push_back)
    front = _swig_new_instance_method(_impl.aliasvector_front)
    back = _swig_new_instance_method(_impl.aliasvector_back)
    assign = _swig_new_instance_method(_impl.aliasvector_assign)
    resize = _swig_new_instance_method(_impl.aliasvector_resize)
    insert = _swig_new_instance_method(_impl.aliasvector_insert)
    reserve = _swig_new_instance_method(_impl.aliasvector_reserve)
    capacity = _swig_new_instance_method(_impl.aliasvector_capacity)
    __swig_destroy__ = _impl.delete_aliasvector

# Register aliasvector in _impl:
_impl.aliasvector_swigregister(aliasvector)
class vectorstring(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_impl.vectorstring_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_impl.vectorstring___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.vectorstring___bool__)
    __len__ = _swig_new_instance_method(_impl.vectorstring___len__)
    __getslice__ = _swig_new_instance_method(_impl.vectorstring___getslice__)
    __setslice__ = _swig_new_instance_method(_impl.vectorstring___setslice__)
    __delslice__ = _swig_new_instance_method(_impl.vectorstring___delslice__)
    __delitem__ = _swig_new_instance_method(_impl.vectorstring___delitem__)
    __getitem__ = _swig_new_instance_method(_impl.vectorstring___getitem__)
    __setitem__ = _swig_new_instance_method(_impl.vectorstring___setitem__)
    pop = _swig_new_instance_method(_impl.vectorstring_pop)
    append = _swig_new_instance_method(_impl.vectorstring_append)
    empty = _swig_new_instance_method(_impl.vectorstring_empty)
    size = _swig_new_instance_method(_impl.vectorstring_size)
    swap = _swig_new_instance_method(_impl.vectorstring_swap)
    begin = _swig_new_instance_method(_impl.vectorstring_begin)
    end = _swig_new_instance_method(_impl.vectorstring_end)
    rbegin = _swig_new_instance_method(_impl.vectorstring_rbegin)
    rend = _swig_new_instance_method(_impl.vectorstring_rend)
    clear = _swig_new_instance_method(_impl.vectorstring_clear)
    get_allocator = _swig_new_instance_method(_impl.vectorstring_get_allocator)
    pop_back = _swig_new_instance_method(_impl.vectorstring_pop_back)
    erase = _swig_new_instance_method(_impl.vectorstring_erase)

    def __init__(self, *args):
        _impl.vectorstring_swiginit(self, _impl.new_vectorstring(*args))
    push_back = _swig_new_instance_method(_impl.vectorstring_push_back)
    front = _swig_new_instance_method(_impl.vectorstring_front)
    back = _swig_new_instance_method(_impl.vectorstring_back)
    assign = _swig_new_instance_method(_impl.vectorstring_assign)
    resize = _swig_new_instance_method(_impl.vectorstring_resize)
    insert = _swig_new_instance_method(_impl.vectorstring_insert)
    reserve = _swig_new_instance_method(_impl.vectorstring_reserve)
    capacity = _swig_new_instance_method(_impl.vectorstring_capacity)
    __swig_destroy__ = _impl.delete_vectorstring

# Register vectorstring in _impl:
_impl.vectorstring_swigregister(vectorstring)
class vectorint(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_impl.vectorint_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_impl.vectorint___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.vectorint___bool__)
    __len__ = _swig_new_instance_method(_impl.vectorint___len__)
    __getslice__ = _swig_new_instance_method(_impl.vectorint___getslice__)
    __setslice__ = _swig_new_instance_method(_impl.vectorint___setslice__)
    __delslice__ = _swig_new_instance_method(_impl.vectorint___delslice__)
    __delitem__ = _swig_new_instance_method(_impl.vectorint___delitem__)
    __getitem__ = _swig_new_instance_method(_impl.vectorint___getitem__)
    __setitem__ = _swig_new_instance_method(_impl.vectorint___setitem__)
    pop = _swig_new_instance_method(_impl.vectorint_pop)
    append = _swig_new_instance_method(_impl.vectorint_append)
    empty = _swig_new_instance_method(_impl.vectorint_empty)
    size = _swig_new_instance_method(_impl.vectorint_size)
    swap = _swig_new_instance_method(_impl.vectorint_swap)
    begin = _swig_new_instance_method(_impl.vectorint_begin)
    end = _swig_new_instance_method(_impl.vectorint_end)
    rbegin = _swig_new_instance_method(_impl.vectorint_rbegin)
    rend = _swig_new_instance_method(_impl.vectorint_rend)
    clear = _swig_new_instance_method(_impl.vectorint_clear)
    get_allocator = _swig_new_instance_method(_impl.vectorint_get_allocator)
    pop_back = _swig_new_instance_method(_impl.vectorint_pop_back)
    erase = _swig_new_instance_method(_impl.vectorint_erase)

    def __init__(self, *args):
        _impl.vectorint_swiginit(self, _impl.new_vectorint(*args))
    push_back = _swig_new_instance_method(_impl.vectorint_push_back)
    front = _swig_new_instance_method(_impl.vectorint_front)
    back = _swig_new_instance_method(_impl.vectorint_back)
    assign = _swig_new_instance_method(_impl.vectorint_assign)
    resize = _swig_new_instance_method(_impl.vectorint_resize)
    insert = _swig_new_instance_method(_impl.vectorint_insert)
    reserve = _swig_new_instance_method(_impl.vectorint_reserve)
    capacity = _swig_new_instance_method(_impl.vectorint_capacity)
    __swig_destroy__ = _impl.delete_vectorint

# Register vectorint in _impl:
_impl.vectorint_swigregister(vectorint)
class pair_formula_vectorstring(object):
    thisown = 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_formula_vectorstring_swiginit(self, _impl.new_pair_formula_vectorstring(*args))
    first = property(_impl.pair_formula_vectorstring_first_get, _impl.pair_formula_vectorstring_first_set)
    second = property(_impl.pair_formula_vectorstring_second_get, _impl.pair_formula_vectorstring_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_formula_vectorstring

# Register pair_formula_vectorstring in _impl:
_impl.pair_formula_vectorstring_swigregister(pair_formula_vectorstring)
class atomic_prop_set(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    iterator = _swig_new_instance_method(_impl.atomic_prop_set_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_impl.atomic_prop_set___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.atomic_prop_set___bool__)
    __len__ = _swig_new_instance_method(_impl.atomic_prop_set___len__)
    append = _swig_new_instance_method(_impl.atomic_prop_set_append)
    __contains__ = _swig_new_instance_method(_impl.atomic_prop_set___contains__)
    __getitem__ = _swig_new_instance_method(_impl.atomic_prop_set___getitem__)
    add = _swig_new_instance_method(_impl.atomic_prop_set_add)
    discard = _swig_new_instance_method(_impl.atomic_prop_set_discard)

    def __init__(self, *args):
        _impl.atomic_prop_set_swiginit(self, _impl.new_atomic_prop_set(*args))
    empty = _swig_new_instance_method(_impl.atomic_prop_set_empty)
    size = _swig_new_instance_method(_impl.atomic_prop_set_size)
    clear = _swig_new_instance_method(_impl.atomic_prop_set_clear)
    swap = _swig_new_instance_method(_impl.atomic_prop_set_swap)
    count = _swig_new_instance_method(_impl.atomic_prop_set_count)
    begin = _swig_new_instance_method(_impl.atomic_prop_set_begin)
    end = _swig_new_instance_method(_impl.atomic_prop_set_end)
    rbegin = _swig_new_instance_method(_impl.atomic_prop_set_rbegin)
    rend = _swig_new_instance_method(_impl.atomic_prop_set_rend)
    erase = _swig_new_instance_method(_impl.atomic_prop_set_erase)
    find = _swig_new_instance_method(_impl.atomic_prop_set_find)
    lower_bound = _swig_new_instance_method(_impl.atomic_prop_set_lower_bound)
    upper_bound = _swig_new_instance_method(_impl.atomic_prop_set_upper_bound)
    equal_range = _swig_new_instance_method(_impl.atomic_prop_set_equal_range)
    insert = _swig_new_instance_method(_impl.atomic_prop_set_insert)
    __str__ = _swig_new_instance_method(_impl.atomic_prop_set___str__)
    __repr__ = _swig_new_instance_method(_impl.atomic_prop_set___repr__)
    __swig_destroy__ = _impl.delete_atomic_prop_set

# Register atomic_prop_set in _impl:
_impl.atomic_prop_set_swigregister(atomic_prop_set)
class vectorofvectorofformulas(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_impl.vectorofvectorofformulas_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_impl.vectorofvectorofformulas___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.vectorofvectorofformulas___bool__)
    __len__ = _swig_new_instance_method(_impl.vectorofvectorofformulas___len__)
    __getslice__ = _swig_new_instance_method(_impl.vectorofvectorofformulas___getslice__)
    __setslice__ = _swig_new_instance_method(_impl.vectorofvectorofformulas___setslice__)
    __delslice__ = _swig_new_instance_method(_impl.vectorofvectorofformulas___delslice__)
    __delitem__ = _swig_new_instance_method(_impl.vectorofvectorofformulas___delitem__)
    __getitem__ = _swig_new_instance_method(_impl.vectorofvectorofformulas___getitem__)
    __setitem__ = _swig_new_instance_method(_impl.vectorofvectorofformulas___setitem__)
    pop = _swig_new_instance_method(_impl.vectorofvectorofformulas_pop)
    append = _swig_new_instance_method(_impl.vectorofvectorofformulas_append)
    empty = _swig_new_instance_method(_impl.vectorofvectorofformulas_empty)
    size = _swig_new_instance_method(_impl.vectorofvectorofformulas_size)
    swap = _swig_new_instance_method(_impl.vectorofvectorofformulas_swap)
    begin = _swig_new_instance_method(_impl.vectorofvectorofformulas_begin)
    end = _swig_new_instance_method(_impl.vectorofvectorofformulas_end)
    rbegin = _swig_new_instance_method(_impl.vectorofvectorofformulas_rbegin)
    rend = _swig_new_instance_method(_impl.vectorofvectorofformulas_rend)
    clear = _swig_new_instance_method(_impl.vectorofvectorofformulas_clear)
    get_allocator = _swig_new_instance_method(_impl.vectorofvectorofformulas_get_allocator)
    pop_back = _swig_new_instance_method(_impl.vectorofvectorofformulas_pop_back)
    erase = _swig_new_instance_method(_impl.vectorofvectorofformulas_erase)

    def __init__(self, *args):
        _impl.vectorofvectorofformulas_swiginit(self, _impl.new_vectorofvectorofformulas(*args))
    push_back = _swig_new_instance_method(_impl.vectorofvectorofformulas_push_back)
    front = _swig_new_instance_method(_impl.vectorofvectorofformulas_front)
    back = _swig_new_instance_method(_impl.vectorofvectorofformulas_back)
    assign = _swig_new_instance_method(_impl.vectorofvectorofformulas_assign)
    resize = _swig_new_instance_method(_impl.vectorofvectorofformulas_resize)
    insert = _swig_new_instance_method(_impl.vectorofvectorofformulas_insert)
    reserve = _swig_new_instance_method(_impl.vectorofvectorofformulas_reserve)
    capacity = _swig_new_instance_method(_impl.vectorofvectorofformulas_capacity)
    __swig_destroy__ = _impl.delete_vectorofvectorofformulas

# Register vectorofvectorofformulas in _impl:
_impl.vectorofvectorofformulas_swigregister(vectorofvectorofformulas)
class setunsigned(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_impl.setunsigned_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_impl.setunsigned___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.setunsigned___bool__)
    __len__ = _swig_new_instance_method(_impl.setunsigned___len__)
    append = _swig_new_instance_method(_impl.setunsigned_append)
    __contains__ = _swig_new_instance_method(_impl.setunsigned___contains__)
    __getitem__ = _swig_new_instance_method(_impl.setunsigned___getitem__)
    add = _swig_new_instance_method(_impl.setunsigned_add)
    discard = _swig_new_instance_method(_impl.setunsigned_discard)

    def __init__(self, *args):
        _impl.setunsigned_swiginit(self, _impl.new_setunsigned(*args))
    empty = _swig_new_instance_method(_impl.setunsigned_empty)
    size = _swig_new_instance_method(_impl.setunsigned_size)
    clear = _swig_new_instance_method(_impl.setunsigned_clear)
    swap = _swig_new_instance_method(_impl.setunsigned_swap)
    count = _swig_new_instance_method(_impl.setunsigned_count)
    begin = _swig_new_instance_method(_impl.setunsigned_begin)
    end = _swig_new_instance_method(_impl.setunsigned_end)
    rbegin = _swig_new_instance_method(_impl.setunsigned_rbegin)
    rend = _swig_new_instance_method(_impl.setunsigned_rend)
    erase = _swig_new_instance_method(_impl.setunsigned_erase)
    find = _swig_new_instance_method(_impl.setunsigned_find)
    lower_bound = _swig_new_instance_method(_impl.setunsigned_lower_bound)
    upper_bound = _swig_new_instance_method(_impl.setunsigned_upper_bound)
    equal_range = _swig_new_instance_method(_impl.setunsigned_equal_range)
    insert = _swig_new_instance_method(_impl.setunsigned_insert)
    __swig_destroy__ = _impl.delete_setunsigned

# Register setunsigned in _impl:
_impl.setunsigned_swigregister(setunsigned)
class relabeling_map(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_impl.relabeling_map_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_impl.relabeling_map___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.relabeling_map___bool__)
    __len__ = _swig_new_instance_method(_impl.relabeling_map___len__)
    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()
    __getitem__ = _swig_new_instance_method(_impl.relabeling_map___getitem__)
    __delitem__ = _swig_new_instance_method(_impl.relabeling_map___delitem__)
    has_key = _swig_new_instance_method(_impl.relabeling_map_has_key)
    keys = _swig_new_instance_method(_impl.relabeling_map_keys)
    values = _swig_new_instance_method(_impl.relabeling_map_values)
    items = _swig_new_instance_method(_impl.relabeling_map_items)
    __contains__ = _swig_new_instance_method(_impl.relabeling_map___contains__)
    key_iterator = _swig_new_instance_method(_impl.relabeling_map_key_iterator)
    value_iterator = _swig_new_instance_method(_impl.relabeling_map_value_iterator)
    __setitem__ = _swig_new_instance_method(_impl.relabeling_map___setitem__)
    asdict = _swig_new_instance_method(_impl.relabeling_map_asdict)

    def __init__(self, *args):
        _impl.relabeling_map_swiginit(self, _impl.new_relabeling_map(*args))
    empty = _swig_new_instance_method(_impl.relabeling_map_empty)
    size = _swig_new_instance_method(_impl.relabeling_map_size)
    swap = _swig_new_instance_method(_impl.relabeling_map_swap)
    begin = _swig_new_instance_method(_impl.relabeling_map_begin)
    end = _swig_new_instance_method(_impl.relabeling_map_end)
    rbegin = _swig_new_instance_method(_impl.relabeling_map_rbegin)
    rend = _swig_new_instance_method(_impl.relabeling_map_rend)
    clear = _swig_new_instance_method(_impl.relabeling_map_clear)
    get_allocator = _swig_new_instance_method(_impl.relabeling_map_get_allocator)
    count = _swig_new_instance_method(_impl.relabeling_map_count)
    erase = _swig_new_instance_method(_impl.relabeling_map_erase)
    find = _swig_new_instance_method(_impl.relabeling_map_find)
    lower_bound = _swig_new_instance_method(_impl.relabeling_map_lower_bound)
    upper_bound = _swig_new_instance_method(_impl.relabeling_map_upper_bound)
    __swig_destroy__ = _impl.delete_relabeling_map

# Register relabeling_map in _impl:
_impl.relabeling_map_swigregister(relabeling_map)
class map_formula_unsignedchar(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_impl.map_formula_unsignedchar_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_impl.map_formula_unsignedchar___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.map_formula_unsignedchar___bool__)
    __len__ = _swig_new_instance_method(_impl.map_formula_unsignedchar___len__)
    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()
    __getitem__ = _swig_new_instance_method(_impl.map_formula_unsignedchar___getitem__)
    __delitem__ = _swig_new_instance_method(_impl.map_formula_unsignedchar___delitem__)
    has_key = _swig_new_instance_method(_impl.map_formula_unsignedchar_has_key)
    keys = _swig_new_instance_method(_impl.map_formula_unsignedchar_keys)
    values = _swig_new_instance_method(_impl.map_formula_unsignedchar_values)
    items = _swig_new_instance_method(_impl.map_formula_unsignedchar_items)
    __contains__ = _swig_new_instance_method(_impl.map_formula_unsignedchar___contains__)
    key_iterator = _swig_new_instance_method(_impl.map_formula_unsignedchar_key_iterator)
    value_iterator = _swig_new_instance_method(_impl.map_formula_unsignedchar_value_iterator)
    __setitem__ = _swig_new_instance_method(_impl.map_formula_unsignedchar___setitem__)
    asdict = _swig_new_instance_method(_impl.map_formula_unsignedchar_asdict)

    def __init__(self, *args):
        _impl.map_formula_unsignedchar_swiginit(self, _impl.new_map_formula_unsignedchar(*args))
    empty = _swig_new_instance_method(_impl.map_formula_unsignedchar_empty)
    size = _swig_new_instance_method(_impl.map_formula_unsignedchar_size)
    swap = _swig_new_instance_method(_impl.map_formula_unsignedchar_swap)
    begin = _swig_new_instance_method(_impl.map_formula_unsignedchar_begin)
    end = _swig_new_instance_method(_impl.map_formula_unsignedchar_end)
    rbegin = _swig_new_instance_method(_impl.map_formula_unsignedchar_rbegin)
    rend = _swig_new_instance_method(_impl.map_formula_unsignedchar_rend)
    clear = _swig_new_instance_method(_impl.map_formula_unsignedchar_clear)
    get_allocator = _swig_new_instance_method(_impl.map_formula_unsignedchar_get_allocator)
    count = _swig_new_instance_method(_impl.map_formula_unsignedchar_count)
    erase = _swig_new_instance_method(_impl.map_formula_unsignedchar_erase)
    find = _swig_new_instance_method(_impl.map_formula_unsignedchar_find)
    lower_bound = _swig_new_instance_method(_impl.map_formula_unsignedchar_lower_bound)
    upper_bound = _swig_new_instance_method(_impl.map_formula_unsignedchar_upper_bound)
    __swig_destroy__ = _impl.delete_map_formula_unsignedchar

# Register map_formula_unsignedchar in _impl:
_impl.map_formula_unsignedchar_swigregister(map_formula_unsignedchar)
class environment(object):
    r"""
    Environment classes can be passed to the parser to interpret and
    restrict the set of atomic propositions. For instance, the
    default_environment will allow all atomic propositions, while
    the declarative_environment will allow only a predeclared set of
    atomic propositions.

    An environment that describes atomic propositions.
    """

    thisown = 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
    require = _swig_new_instance_method(_impl.environment_require)
    name = _swig_new_instance_method(_impl.environment_name)
    __swig_destroy__ = _impl.delete_environment

# Register environment in _impl:
_impl.environment_swigregister(environment)
class declarative_environment(environment):
    r"""
    A declarative environment.

    This environment recognizes all atomic propositions
    that have been previously declared.  It will reject others.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _impl.declarative_environment_swiginit(self, _impl.new_declarative_environment())
    __swig_destroy__ = _impl.delete_declarative_environment
    declare = _swig_new_instance_method(_impl.declarative_environment_declare)
    get_prop_map = _swig_new_instance_method(_impl.declarative_environment_get_prop_map)

# Register declarative_environment in _impl:
_impl.declarative_environment_swigregister(declarative_environment)
class default_environment(environment):
    r"""
    A laxist environment.

    This environment recognizes all atomic propositions.

    This is a singleton.  Use default_environment::instance()
    to obtain the instance.
    """

    thisown = 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 = _swig_new_static_method(_impl.default_environment_instance)

# Register default_environment in _impl:
_impl.default_environment_swigregister(default_environment)
class parse_error_list(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __nonzero__ = _swig_new_instance_method(_impl.parse_error_list___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.parse_error_list___bool__)

    def __init__(self):
        _impl.parse_error_list_swiginit(self, _impl.new_parse_error_list())
    __swig_destroy__ = _impl.delete_parse_error_list

# Register parse_error_list in _impl:
_impl.parse_error_list_swigregister(parse_error_list)
class parsed_formula(object):
    r"""The result of a formula parser."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    f = property(_impl.parsed_formula_f_get, _impl.parsed_formula_f_set, doc=r"""
    The parsed formula.

    This could be formula(nullptr) in case of a serious parse error.
    """)
    input = property(_impl.parsed_formula_input_get, _impl.parsed_formula_input_set, doc=r"""The input text, before parsing.""")
    errors = property(_impl.parsed_formula_errors_get, _impl.parsed_formula_errors_set, doc=r"""
    Syntax errors that occurred during parsing.

    Note that the parser does not print any diagnostic.
    Deciding how to output those errors is up to you.

    See also: format_errors
    """)

    def __init__(self, *args):
        r"""Construct with *str* as the input text before parsing."""
        _impl.parsed_formula_swiginit(self, _impl.new_parsed_formula(*args))
    format_errors = _swig_new_instance_method(_impl.parsed_formula_format_errors)
    __swig_destroy__ = _impl.delete_parsed_formula

# Register parsed_formula in _impl:
_impl.parsed_formula_swigregister(parsed_formula)
parse_infix_psl = _impl.parse_infix_psl
parse_infix_boolean = _impl.parse_infix_boolean
parse_prefix_ltl = _impl.parse_prefix_ltl
parse_formula = _impl.parse_formula
parse_infix_sere = _impl.parse_infix_sere
fix_utf8_locations = _impl.fix_utf8_locations
class bdd_dict(object):
    r"""
    Map BDD variables to formulas.

    The BDD library uses integers to designate Boolean variables in
    its decision diagrams.  This class is used to map such integers
    to objects actually used in Spot.  These objects are usually
    atomic propositions, but they can also be acceptance conditions.

    When a BDD variable is registered using a bdd_dict, it is always
    associated to a "user" (or "owner") object.  This is done by
    supplying the bdd_dict with a pointer to the intended user of
    the variable.  When the user object dies, it should release the
    BDD variables it was using by calling (for instance)
    unregister_all_my_variables(), giving the same pointer.
    Variables can also by unregistered one by one using
    unregister_variable().
    """

    thisown = 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 = property(_impl.bdd_dict_var_map_get, _impl.bdd_dict_var_map_set, doc=r"""Maps atomic propositions to BDD variables""")
    acc_map = property(_impl.bdd_dict_acc_map_get, _impl.bdd_dict_acc_map_set, doc=r"""Maps acceptance conditions to BDD variables""")
    anon = _impl.bdd_dict_anon
    r"""Anonymous variable (no formula associated)."""
    var = _impl.bdd_dict_var
    r"""Atomic-proposition variable."""
    acc = _impl.bdd_dict_acc
    r"""Acceptance-condition variable."""
    bdd_map = property(_impl.bdd_dict_bdd_map_get, _impl.bdd_dict_bdd_map_set, doc=r"""Table mapping BDD variable numbers to their meaning.""")
    has_registered_proposition = _swig_new_instance_method(_impl.bdd_dict_has_registered_proposition)
    varnum = _swig_new_instance_method(_impl.bdd_dict_varnum)
    ap_from_var = _swig_new_instance_method(_impl.bdd_dict_ap_from_var)
    register_acceptance_variable = _swig_new_instance_method(_impl.bdd_dict_register_acceptance_variable)
    register_all_propositions_of = _swig_new_instance_method(_impl.bdd_dict_register_all_propositions_of)
    dump = _swig_new_instance_method(_impl.bdd_dict_dump)
    assert_emptiness = _swig_new_instance_method(_impl.bdd_dict_assert_emptiness)
    __eq__ = _swig_new_instance_method(_impl.bdd_dict___eq__)
    __ne__ = _swig_new_instance_method(_impl.bdd_dict___ne__)
    register_proposition = _swig_new_instance_method(_impl.bdd_dict_register_proposition)
    unregister_all_my_variables = _swig_new_instance_method(_impl.bdd_dict_unregister_all_my_variables)
    unregister_variable = _swig_new_instance_method(_impl.bdd_dict_unregister_variable)
    register_all_variables_of = _swig_new_instance_method(_impl.bdd_dict_register_all_variables_of)
    register_anonymous_variables = _swig_new_instance_method(_impl.bdd_dict_register_anonymous_variables)

# Register bdd_dict in _impl:
_impl.bdd_dict_swigregister(bdd_dict)
make_bdd_dict = _impl.make_bdd_dict
class bdd_dict_preorder(object):
    r"""
    A BDD dictionary wrapper that pre-registers atomic propositions
    before use.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""Construct from an existing bdd_dict."""
        _impl.bdd_dict_preorder_swiginit(self, _impl.new_bdd_dict_preorder(*args))
    get_dict = _swig_new_instance_method(_impl.bdd_dict_preorder_get_dict)
    register_proposition = _swig_new_instance_method(_impl.bdd_dict_preorder_register_proposition)
    __swig_destroy__ = _impl.delete_bdd_dict_preorder

# Register bdd_dict_preorder in _impl:
_impl.bdd_dict_preorder_swigregister(bdd_dict_preorder)
bdd_print_sat = _impl.bdd_print_sat
bdd_format_sat = _impl.bdd_format_sat
bdd_print_accset = _impl.bdd_print_accset
bdd_format_accset = _impl.bdd_format_accset
bdd_print_set = _impl.bdd_print_set
bdd_format_set = _impl.bdd_format_set
bdd_print_formula = _impl.bdd_print_formula
bdd_format_formula = _impl.bdd_format_formula
enable_utf8 = _impl.enable_utf8
bdd_format_isop = _impl.bdd_format_isop
bdd_print_isop = _impl.bdd_print_isop
bdd_to_formula = _impl.bdd_to_formula
bdd_to_cnf_formula = _impl.bdd_to_cnf_formula
formula_to_bdd = _impl.formula_to_bdd
class vector_rs_pair(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_impl.vector_rs_pair_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_impl.vector_rs_pair___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.vector_rs_pair___bool__)
    __len__ = _swig_new_instance_method(_impl.vector_rs_pair___len__)
    __getslice__ = _swig_new_instance_method(_impl.vector_rs_pair___getslice__)
    __setslice__ = _swig_new_instance_method(_impl.vector_rs_pair___setslice__)
    __delslice__ = _swig_new_instance_method(_impl.vector_rs_pair___delslice__)
    __delitem__ = _swig_new_instance_method(_impl.vector_rs_pair___delitem__)
    __getitem__ = _swig_new_instance_method(_impl.vector_rs_pair___getitem__)
    __setitem__ = _swig_new_instance_method(_impl.vector_rs_pair___setitem__)
    pop = _swig_new_instance_method(_impl.vector_rs_pair_pop)
    append = _swig_new_instance_method(_impl.vector_rs_pair_append)
    empty = _swig_new_instance_method(_impl.vector_rs_pair_empty)
    size = _swig_new_instance_method(_impl.vector_rs_pair_size)
    swap = _swig_new_instance_method(_impl.vector_rs_pair_swap)
    begin = _swig_new_instance_method(_impl.vector_rs_pair_begin)
    end = _swig_new_instance_method(_impl.vector_rs_pair_end)
    rbegin = _swig_new_instance_method(_impl.vector_rs_pair_rbegin)
    rend = _swig_new_instance_method(_impl.vector_rs_pair_rend)
    clear = _swig_new_instance_method(_impl.vector_rs_pair_clear)
    get_allocator = _swig_new_instance_method(_impl.vector_rs_pair_get_allocator)
    pop_back = _swig_new_instance_method(_impl.vector_rs_pair_pop_back)
    erase = _swig_new_instance_method(_impl.vector_rs_pair_erase)

    def __init__(self, *args):
        _impl.vector_rs_pair_swiginit(self, _impl.new_vector_rs_pair(*args))
    push_back = _swig_new_instance_method(_impl.vector_rs_pair_push_back)
    front = _swig_new_instance_method(_impl.vector_rs_pair_front)
    back = _swig_new_instance_method(_impl.vector_rs_pair_back)
    assign = _swig_new_instance_method(_impl.vector_rs_pair_assign)
    resize = _swig_new_instance_method(_impl.vector_rs_pair_resize)
    insert = _swig_new_instance_method(_impl.vector_rs_pair_insert)
    reserve = _swig_new_instance_method(_impl.vector_rs_pair_reserve)
    capacity = _swig_new_instance_method(_impl.vector_rs_pair_capacity)
    __swig_destroy__ = _impl.delete_vector_rs_pair

# Register vector_rs_pair in _impl:
_impl.vector_rs_pair_swigregister(vector_rs_pair)
class acc_cond(object):
    r"""
    An acceptance condition

    This represent an acceptance condition in the HOA sense, that
    is, an acceptance formula plus a number of acceptance sets.  The
    acceptance formula is expected to use a subset of the acceptance
    sets.  (It usually uses *all* sets, otherwise that means that
    some of the sets have no influence on the automaton language and
    could be removed.)
    """

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

    def __init__(self, *args):
        r"""
        *Overload 1:*
        Build an acceptance condition

        This takes a number of sets *n_sets*, and an acceptance
        formula (*code)* over those sets.

        The number of sets should be at least cover all the sets used
        in *code*.

        |

        *Overload 2:*
        Build an acceptance condition

        In this version, the number of sets is set to the smallest
        number necessary for *code*.

        |

        *Overload 3:*
        Copy an acceptance condition
        """
        _impl.acc_cond_swiginit(self, _impl.new_acc_cond(*args))
    __swig_destroy__ = _impl.delete_acc_cond
    set_acceptance = _swig_new_instance_method(_impl.acc_cond_set_acceptance)
    get_acceptance = _swig_new_instance_method(_impl.acc_cond_get_acceptance)
    __eq__ = _swig_new_instance_method(_impl.acc_cond___eq__)
    __ne__ = _swig_new_instance_method(_impl.acc_cond___ne__)
    uses_fin_acceptance = _swig_new_instance_method(_impl.acc_cond_uses_fin_acceptance)
    is_t = _swig_new_instance_method(_impl.acc_cond_is_t)
    is_all = _swig_new_instance_method(_impl.acc_cond_is_all)
    is_f = _swig_new_instance_method(_impl.acc_cond_is_f)
    is_none = _swig_new_instance_method(_impl.acc_cond_is_none)
    is_buchi = _swig_new_instance_method(_impl.acc_cond_is_buchi)
    is_co_buchi = _swig_new_instance_method(_impl.acc_cond_is_co_buchi)
    set_generalized_buchi = _swig_new_instance_method(_impl.acc_cond_set_generalized_buchi)
    set_generalized_co_buchi = _swig_new_instance_method(_impl.acc_cond_set_generalized_co_buchi)
    is_generalized_buchi = _swig_new_instance_method(_impl.acc_cond_is_generalized_buchi)
    is_generalized_co_buchi = _swig_new_instance_method(_impl.acc_cond_is_generalized_co_buchi)
    is_rabin = _swig_new_instance_method(_impl.acc_cond_is_rabin)
    is_streett = _swig_new_instance_method(_impl.acc_cond_is_streett)
    is_streett_like = _swig_new_instance_method(_impl.acc_cond_is_streett_like)
    is_rabin_like = _swig_new_instance_method(_impl.acc_cond_is_rabin_like)
    is_generalized_rabin = _swig_new_instance_method(_impl.acc_cond_is_generalized_rabin)
    is_generalized_streett = _swig_new_instance_method(_impl.acc_cond_is_generalized_streett)
    is_parity = _swig_new_instance_method(_impl.acc_cond_is_parity)
    unit_propagation = _swig_new_instance_method(_impl.acc_cond_unit_propagation)
    unsat_mark = _swig_new_instance_method(_impl.acc_cond_unsat_mark)
    sat_mark = _swig_new_instance_method(_impl.acc_cond_sat_mark)
    inf = _swig_new_static_method(_impl.acc_cond_inf)
    inf_neg = _swig_new_static_method(_impl.acc_cond_inf_neg)
    fin = _swig_new_static_method(_impl.acc_cond_fin)
    fin_neg = _swig_new_static_method(_impl.acc_cond_fin_neg)
    add_sets = _swig_new_instance_method(_impl.acc_cond_add_sets)
    add_set = _swig_new_instance_method(_impl.acc_cond_add_set)
    mark = _swig_new_instance_method(_impl.acc_cond_mark)
    comp = _swig_new_instance_method(_impl.acc_cond_comp)
    all_sets = _swig_new_instance_method(_impl.acc_cond_all_sets)
    accepting = _swig_new_instance_method(_impl.acc_cond_accepting)
    inf_satisfiable = _swig_new_instance_method(_impl.acc_cond_inf_satisfiable)
    keep_one_inf_per_branch = _swig_new_instance_method(_impl.acc_cond_keep_one_inf_per_branch)
    maybe_accepting = _swig_new_instance_method(_impl.acc_cond_maybe_accepting)
    weakly_accepting = _swig_new_instance_method(_impl.acc_cond_weakly_accepting)
    accepting_sets = _swig_new_instance_method(_impl.acc_cond_accepting_sets)
    num_sets = _swig_new_instance_method(_impl.acc_cond_num_sets)
    remove = _swig_new_instance_method(_impl.acc_cond_remove)
    strip = _swig_new_instance_method(_impl.acc_cond_strip)
    force_inf = _swig_new_instance_method(_impl.acc_cond_force_inf)
    restrict_to = _swig_new_instance_method(_impl.acc_cond_restrict_to)
    name = _swig_new_instance_method(_impl.acc_cond_name)
    fin_unit = _swig_new_instance_method(_impl.acc_cond_fin_unit)
    mafins = _swig_new_instance_method(_impl.acc_cond_mafins)
    mafins_split = _swig_new_instance_method(_impl.acc_cond_mafins_split)
    inf_unit = _swig_new_instance_method(_impl.acc_cond_inf_unit)
    fin_one = _swig_new_instance_method(_impl.acc_cond_fin_one)
    fin_one_extract = _swig_new_instance_method(_impl.acc_cond_fin_one_extract)
    fin_unit_one_split = _swig_new_instance_method(_impl.acc_cond_fin_unit_one_split)
    fin_unit_one_split_improved = _swig_new_instance_method(_impl.acc_cond_fin_unit_one_split_improved)
    top_disjuncts = _swig_new_instance_method(_impl.acc_cond_top_disjuncts)
    top_conjuncts = _swig_new_instance_method(_impl.acc_cond_top_conjuncts)
    __repr__ = _swig_new_instance_method(_impl.acc_cond___repr__)
    __str__ = _swig_new_instance_method(_impl.acc_cond___str__)

# Register acc_cond in _impl:
_impl.acc_cond_swigregister(acc_cond)
class mark_t(object):
    r"""
    An acceptance mark

    This type is used to represent a set of acceptance sets.  It
    works (and is implemented) like a bit vector where bit at
    index i represents the membership to the i-th acceptance set.

    Typically, each transition of an automaton is labeled by a
    mark_t that represents the membership of the transition to
    each of the acceptance sets.

    For efficiency reason, the maximum number of acceptance sets
    (i.e., the size of the bit vector) supported is a compile-time
    constant.  It can be changed by passing an option to the
    configure script of Spot.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    max_accsets = _swig_new_static_method(_impl.mark_t_max_accsets)
    all = _swig_new_static_method(_impl.mark_t_all)
    hash = _swig_new_instance_method(_impl.mark_t_hash)
    __eq__ = _swig_new_instance_method(_impl.mark_t___eq__)
    __ne__ = _swig_new_instance_method(_impl.mark_t___ne__)
    __lt__ = _swig_new_instance_method(_impl.mark_t___lt__)
    __le__ = _swig_new_instance_method(_impl.mark_t___le__)
    __gt__ = _swig_new_instance_method(_impl.mark_t___gt__)
    __ge__ = _swig_new_instance_method(_impl.mark_t___ge__)

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


    has = _swig_new_instance_method(_impl.mark_t_has)
    set = _swig_new_instance_method(_impl.mark_t_set)
    clear = _swig_new_instance_method(_impl.mark_t_clear)
    __iand__ = _swig_new_instance_method(_impl.mark_t___iand__)
    __ior__ = _swig_new_instance_method(_impl.mark_t___ior__)
    __isub__ = _swig_new_instance_method(_impl.mark_t___isub__)
    __ixor__ = _swig_new_instance_method(_impl.mark_t___ixor__)
    __and__ = _swig_new_instance_method(_impl.mark_t___and__)
    __or__ = _swig_new_instance_method(_impl.mark_t___or__)
    __sub__ = _swig_new_instance_method(_impl.mark_t___sub__)
    __invert__ = _swig_new_instance_method(_impl.mark_t___invert__)
    __xor__ = _swig_new_instance_method(_impl.mark_t___xor__)
    __lshift__ = _swig_new_instance_method(_impl.mark_t___lshift__)
    __ilshift__ = _swig_new_instance_method(_impl.mark_t___ilshift__)
    __rshift__ = _swig_new_instance_method(_impl.mark_t___rshift__)
    __irshift__ = _swig_new_instance_method(_impl.mark_t___irshift__)
    strip = _swig_new_instance_method(_impl.mark_t_strip)
    subset = _swig_new_instance_method(_impl.mark_t_subset)
    proper_subset = _swig_new_instance_method(_impl.mark_t_proper_subset)
    count = _swig_new_instance_method(_impl.mark_t_count)
    max_set = _swig_new_instance_method(_impl.mark_t_max_set)
    min_set = _swig_new_instance_method(_impl.mark_t_min_set)
    lowest = _swig_new_instance_method(_impl.mark_t_lowest)
    is_singleton = _swig_new_instance_method(_impl.mark_t_is_singleton)
    has_many = _swig_new_instance_method(_impl.mark_t_has_many)
    remove_some = _swig_new_instance_method(_impl.mark_t_remove_some)
    sets = _swig_new_instance_method(_impl.mark_t_sets)
    as_string = _swig_new_instance_method(_impl.mark_t_as_string)

    def __init__(self, *args):
        r"""Initialize an empty mark_t."""
        _impl.mark_t_swiginit(self, _impl.new_mark_t(*args))
    __repr__ = _swig_new_instance_method(_impl.mark_t___repr__)
    __str__ = _swig_new_instance_method(_impl.mark_t___str__)
    __swig_destroy__ = _impl.delete_mark_t

# Register mark_t in _impl:
_impl.mark_t_swigregister(mark_t)
class acc_code(object):
    r"""
    An acceptance formula.

    Acceptance formulas are stored as a vector of acc_word in a
    kind of reverse polish notation.  The motivation for this
    design was that we could evaluate the acceptance condition
    using a very simple stack-based interpreter; however it turned
    out that such a stack-based interpretation would prevent us
    from doing short-circuit evaluation, so we are not evaluating
    acceptance conditions this way, and maybe the implementation
    of acc_code could change in the future.  It's best not to rely
    on the fact that formulas are stored as vectors.  Use the
    provided methods instead.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    unit_propagation = _swig_new_instance_method(_impl.acc_code_unit_propagation)
    __eq__ = _swig_new_instance_method(_impl.acc_code___eq__)
    __lt__ = _swig_new_instance_method(_impl.acc_code___lt__)
    __gt__ = _swig_new_instance_method(_impl.acc_code___gt__)
    __le__ = _swig_new_instance_method(_impl.acc_code___le__)
    __ge__ = _swig_new_instance_method(_impl.acc_code___ge__)
    __ne__ = _swig_new_instance_method(_impl.acc_code___ne__)
    is_t = _swig_new_instance_method(_impl.acc_code_is_t)
    is_f = _swig_new_instance_method(_impl.acc_code_is_f)
    f = _swig_new_static_method(_impl.acc_code_f)
    t = _swig_new_static_method(_impl.acc_code_t)
    fin = _swig_new_static_method(_impl.acc_code_fin)
    fin_neg = _swig_new_static_method(_impl.acc_code_fin_neg)
    inf = _swig_new_static_method(_impl.acc_code_inf)
    inf_neg = _swig_new_static_method(_impl.acc_code_inf_neg)
    buchi = _swig_new_static_method(_impl.acc_code_buchi)
    cobuchi = _swig_new_static_method(_impl.acc_code_cobuchi)
    generalized_buchi = _swig_new_static_method(_impl.acc_code_generalized_buchi)
    generalized_co_buchi = _swig_new_static_method(_impl.acc_code_generalized_co_buchi)
    rabin = _swig_new_static_method(_impl.acc_code_rabin)
    streett = _swig_new_static_method(_impl.acc_code_streett)
    parity = _swig_new_static_method(_impl.acc_code_parity)
    parity_max = _swig_new_static_method(_impl.acc_code_parity_max)
    parity_max_odd = _swig_new_static_method(_impl.acc_code_parity_max_odd)
    parity_max_even = _swig_new_static_method(_impl.acc_code_parity_max_even)
    parity_min = _swig_new_static_method(_impl.acc_code_parity_min)
    parity_min_odd = _swig_new_static_method(_impl.acc_code_parity_min_odd)
    parity_min_even = _swig_new_static_method(_impl.acc_code_parity_min_even)
    random = _swig_new_static_method(_impl.acc_code_random)
    __iand__ = _swig_new_instance_method(_impl.acc_code___iand__)
    __and__ = _swig_new_instance_method(_impl.acc_code___and__)
    __ior__ = _swig_new_instance_method(_impl.acc_code___ior__)
    __or__ = _swig_new_instance_method(_impl.acc_code___or__)
    __ilshift__ = _swig_new_instance_method(_impl.acc_code___ilshift__)
    __lshift__ = _swig_new_instance_method(_impl.acc_code___lshift__)
    is_dnf = _swig_new_instance_method(_impl.acc_code_is_dnf)
    is_cnf = _swig_new_instance_method(_impl.acc_code_is_cnf)
    to_dnf = _swig_new_instance_method(_impl.acc_code_to_dnf)
    to_cnf = _swig_new_instance_method(_impl.acc_code_to_cnf)
    to_bdd = _swig_new_instance_method(_impl.acc_code_to_bdd)
    top_disjuncts = _swig_new_instance_method(_impl.acc_code_top_disjuncts)
    top_conjuncts = _swig_new_instance_method(_impl.acc_code_top_conjuncts)
    complement = _swig_new_instance_method(_impl.acc_code_complement)
    fin_unit = _swig_new_instance_method(_impl.acc_code_fin_unit)
    mafins = _swig_new_instance_method(_impl.acc_code_mafins)
    inf_unit = _swig_new_instance_method(_impl.acc_code_inf_unit)
    fin_one = _swig_new_instance_method(_impl.acc_code_fin_one)
    fin_one_extract = _swig_new_instance_method(_impl.acc_code_fin_one_extract)
    fin_unit_one_split = _swig_new_instance_method(_impl.acc_code_fin_unit_one_split)
    fin_unit_one_split_improved = _swig_new_instance_method(_impl.acc_code_fin_unit_one_split_improved)
    mafins_split = _swig_new_instance_method(_impl.acc_code_mafins_split)
    missing = _swig_new_instance_method(_impl.acc_code_missing)
    accepting = _swig_new_instance_method(_impl.acc_code_accepting)
    inf_satisfiable = _swig_new_instance_method(_impl.acc_code_inf_satisfiable)
    maybe_accepting = _swig_new_instance_method(_impl.acc_code_maybe_accepting)
    weakly_accepting = _swig_new_instance_method(_impl.acc_code_weakly_accepting)
    symmetries = _swig_new_instance_method(_impl.acc_code_symmetries)
    remove = _swig_new_instance_method(_impl.acc_code_remove)
    strip = _swig_new_instance_method(_impl.acc_code_strip)
    force_inf = _swig_new_instance_method(_impl.acc_code_force_inf)
    keep_one_inf_per_branch = _swig_new_instance_method(_impl.acc_code_keep_one_inf_per_branch)
    used_sets = _swig_new_instance_method(_impl.acc_code_used_sets)
    useless_colors_patterns = _swig_new_instance_method(_impl.acc_code_useless_colors_patterns)
    used_once_sets = _swig_new_instance_method(_impl.acc_code_used_once_sets)
    used_inf_fin_sets = _swig_new_instance_method(_impl.acc_code_used_inf_fin_sets)
    to_html = _swig_new_instance_method(_impl.acc_code_to_html)
    to_text = _swig_new_instance_method(_impl.acc_code_to_text)
    to_latex = _swig_new_instance_method(_impl.acc_code_to_latex)

    def __init__(self, *args):
        r"""
        *Overload 1:*
        Construct an acc_code from a string.

        The string should either follow the following grammar:


          acc ::= "t"
                | "f"
                | "Inf" "(" num ")"
                | "Fin" "(" num ")"
                | "(" acc ")"
                | acc "&" acc
                | acc "|" acc


        Where num is an integer and "&" has priority over "|".  Note that
        "Fin(!x)" and "Inf(!x)" are not supported by this parser.

        Or the string could be the name of an acceptance condition, as
        specified in the HOA format.  (E.g. "Rabin 2", "parity max odd 3",
        "generalized-Rabin 4 2 1", etc.).

        A 'parse_error' is thrown on syntax error.

        |

        *Overload 2:*
        Build an empty acceptance formula.

        This is the same as t().

        |

        *Overload 3:*
        Copy a part of another acceptance formula
        """
        _impl.acc_code_swiginit(self, _impl.new_acc_code(*args))
    __repr__ = _swig_new_instance_method(_impl.acc_code___repr__)
    __str__ = _swig_new_instance_method(_impl.acc_code___str__)
    __swig_destroy__ = _impl.delete_acc_code

# Register acc_code in _impl:
_impl.acc_code_swigregister(acc_code)
class rs_pair(object):
    r"""
    Rabin/streett pairs used by is_rabin_like and is_streett_like.

    These pairs hold two marks which can each contain one or no set number.

    For instance is_streett_like() rewrites  Inf(0)&(Inf(2)|Fin(1))&Fin(3)
    as three pairs: [(fin={},inf={0}),(fin={1},inf={2}),(fin={3},inf={})].

    Empty marks should be interpreted in a way that makes them
    false in Streett, and true in Rabin.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, fin, inf):
        r"""Construct a pair with Fin mark *fin* and Inf mark *inf*."""
        _impl.rs_pair_swiginit(self, _impl.new_rs_pair(fin, inf))
    fin = property(_impl.rs_pair_fin_get, _impl.rs_pair_fin_set, doc=r"""The Fin acceptance mark of this pair.""")
    inf = property(_impl.rs_pair_inf_get, _impl.rs_pair_inf_set, doc=r"""The Inf acceptance mark of this pair.""")
    __eq__ = _swig_new_instance_method(_impl.rs_pair___eq__)
    __ne__ = _swig_new_instance_method(_impl.rs_pair___ne__)
    __lt__ = _swig_new_instance_method(_impl.rs_pair___lt__)
    __le__ = _swig_new_instance_method(_impl.rs_pair___le__)
    __gt__ = _swig_new_instance_method(_impl.rs_pair___gt__)
    __ge__ = _swig_new_instance_method(_impl.rs_pair___ge__)
    __repr__ = _swig_new_instance_method(_impl.rs_pair___repr__)
    __swig_destroy__ = _impl.delete_rs_pair

# Register rs_pair in _impl:
_impl.rs_pair_swigregister(rs_pair)
class rs_pairs_view(object):
    r"""
    A view over Rabin-Streett pairs restricted to a subset of
    acceptance marks.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        *Overload 1:*
        Create a view of pairs *p* restricted to marks visible in *m*.

        |

        *Overload 2:*
        Create an unrestricted view of all pairs in *p*.
        """
        _impl.rs_pairs_view_swiginit(self, _impl.new_rs_pairs_view(*args))
    infs = _swig_new_instance_method(_impl.rs_pairs_view_infs)
    fins = _swig_new_instance_method(_impl.rs_pairs_view_fins)
    fins_alone = _swig_new_instance_method(_impl.rs_pairs_view_fins_alone)
    infs_alone = _swig_new_instance_method(_impl.rs_pairs_view_infs_alone)
    paired_with_fin = _swig_new_instance_method(_impl.rs_pairs_view_paired_with_fin)
    pairs = _swig_new_instance_method(_impl.rs_pairs_view_pairs)
    __swig_destroy__ = _impl.delete_rs_pairs_view

# Register rs_pairs_view in _impl:
_impl.rs_pairs_view_swigregister(rs_pairs_view)
class mark_iterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

# Register mark_iterator in _impl:
_impl.mark_iterator_swigregister(mark_iterator)
class mark_container(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, m):
        _impl.mark_container_swiginit(self, _impl.new_mark_container(m))
    begin = _swig_new_instance_method(_impl.mark_container_begin)
    end = _swig_new_instance_method(_impl.mark_container_end)
    __iter__ = _swig_new_instance_method(_impl.mark_container___iter__)
    __swig_destroy__ = _impl.delete_mark_container

# Register mark_container in _impl:
_impl.mark_container_swigregister(mark_container)
class pair_bool_mark(object):
    thisown = 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 = property(_impl.pair_bool_mark_first_get, _impl.pair_bool_mark_first_set)
    second = 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

# Register pair_bool_mark in _impl:
_impl.pair_bool_mark_swigregister(pair_bool_mark)
class state(object):
    r"""Abstract class for states."""

    thisown = 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
    compare = _swig_new_instance_method(_impl.state_compare)
    hash = _swig_new_instance_method(_impl.state_hash)
    clone = _swig_new_instance_method(_impl.state_clone)
    destroy = _swig_new_instance_method(_impl.state_destroy)

# Register state in _impl:
_impl.state_swigregister(state)
class state_ptr_less_than(object):
    r"""
    Strict Weak Ordering for state pointers.

    This is meant to be used as a comparison functor for
    STL ``map`` whose keys are state pointers.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __call__ = _swig_new_instance_method(_impl.state_ptr_less_than___call__)

    def __init__(self):
        _impl.state_ptr_less_than_swiginit(self, _impl.new_state_ptr_less_than())
    __swig_destroy__ = _impl.delete_state_ptr_less_than

# Register state_ptr_less_than in _impl:
_impl.state_ptr_less_than_swigregister(state_ptr_less_than)
class state_ptr_equal(object):
    r"""
    An Equivalence Relation for state pointers.

    This is meant to be used as a comparison functor for
    an ``unordered_map`` whose keys are state pointers.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __call__ = _swig_new_instance_method(_impl.state_ptr_equal___call__)

    def __init__(self):
        _impl.state_ptr_equal_swiginit(self, _impl.new_state_ptr_equal())
    __swig_destroy__ = _impl.delete_state_ptr_equal

# Register state_ptr_equal in _impl:
_impl.state_ptr_equal_swigregister(state_ptr_equal)
class state_ptr_hash(object):
    r"""
    Hash Function for state pointers.

    This is meant to be used as a hash functor for
    an ``unordered_map`` whose keys are state pointers.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __call__ = _swig_new_instance_method(_impl.state_ptr_hash___call__)

    def __init__(self):
        _impl.state_ptr_hash_swiginit(self, _impl.new_state_ptr_hash())
    __swig_destroy__ = _impl.delete_state_ptr_hash

# Register state_ptr_hash in _impl:
_impl.state_ptr_hash_swigregister(state_ptr_hash)
class state_unicity_table(object):
    r"""Render state pointers unique via a hash table."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __call__ = _swig_new_instance_method(_impl.state_unicity_table___call__)
    is_new = _swig_new_instance_method(_impl.state_unicity_table_is_new)
    __swig_destroy__ = _impl.delete_state_unicity_table
    size = _swig_new_instance_method(_impl.state_unicity_table_size)

    def __init__(self):
        _impl.state_unicity_table_swiginit(self, _impl.new_state_unicity_table())

# Register state_unicity_table in _impl:
_impl.state_unicity_table_swigregister(state_unicity_table)
shared_state_deleter = _impl.shared_state_deleter
class state_shared_ptr_less_than(object):
    r"""
    Strict Weak Ordering for ``shared_state``.

    This is meant to be used as a comparison functor for
    STL ``map`` whose keys are of type ``shared_state``.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __call__ = _swig_new_instance_method(_impl.state_shared_ptr_less_than___call__)

    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

# Register state_shared_ptr_less_than in _impl:
_impl.state_shared_ptr_less_than_swigregister(state_shared_ptr_less_than)
class state_shared_ptr_equal(object):
    r"""
    An Equivalence Relation for ``shared_state``.

    This is meant to be used as a comparison functor for
    an ``unordered_map`` whose keys are of type ``shared_state``.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __call__ = _swig_new_instance_method(_impl.state_shared_ptr_equal___call__)

    def __init__(self):
        _impl.state_shared_ptr_equal_swiginit(self, _impl.new_state_shared_ptr_equal())
    __swig_destroy__ = _impl.delete_state_shared_ptr_equal

# Register state_shared_ptr_equal in _impl:
_impl.state_shared_ptr_equal_swigregister(state_shared_ptr_equal)
class state_shared_ptr_hash(object):
    r"""
    Hash Function for ``shared_state``.

    This is meant to be used as a hash functor for
    an ``unordered_map`` whose keys are of type ``shared_state``.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __call__ = _swig_new_instance_method(_impl.state_shared_ptr_hash___call__)

    def __init__(self):
        _impl.state_shared_ptr_hash_swiginit(self, _impl.new_state_shared_ptr_hash())
    __swig_destroy__ = _impl.delete_state_shared_ptr_hash

# Register state_shared_ptr_hash in _impl:
_impl.state_shared_ptr_hash_swigregister(state_shared_ptr_hash)
class twa_succ_iterator(object):
    r"""
    Iterate over the successors of a state.

    This class provides the basic functionality required to iterate
    over the set of edges leaving a given state.  Instance of
    twa_succ_iterator should normally not be created directly.
    Instead, they are created by passing a "source" state to
    twa::succ_iter(), which will create the instance of
    twa_succ_iterator to iterate over the successors of that state.

    This twa_succ_iterator class offers two types of services,
    offered by two groups of methods.  The methods first(), next(),
    and done() allow iteration over the set of outgoing edges.
    The methods cond(), acc(), dst(), allow inspecting the current
    edge.

    The twa_succ_iterator is usually subclassed so that iteration
    methods and accessor methods can be implemented differently in
    different automata.  In particular, this interface allows
    computing the set of successors on the fly if needed.

    The iterator can be used to iterate over all successors in a
    loop as follows:

    .. code-block:: c++

            for (i->first(); !i->done(); i->next())
              {
       use i->cond(), i->acc(), i->dst()
              }

    If there are n successors, there will be 1 call to first(), n
    calls to next() and n+1 calls to done(), so a total of 2(n+1)
    calls to virtual methods just to handle the iteration.  For this
    reason, we usually favor the following more efficient way of
    performing the same loop:

    .. code-block:: c++

            if (i->first())
              do
                {
       use i->cond(), i->acc(), i->dst()
                }
              while(i->next());

    This loop uses the return value of first() and next() to save
    n+1 calls to done().
    """

    thisown = 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
    first = _swig_new_instance_method(_impl.twa_succ_iterator_first)
    next = _swig_new_instance_method(_impl.twa_succ_iterator_next)
    done = _swig_new_instance_method(_impl.twa_succ_iterator_done)
    dst = _swig_new_instance_method(_impl.twa_succ_iterator_dst)
    cond = _swig_new_instance_method(_impl.twa_succ_iterator_cond)
    acc = _swig_new_instance_method(_impl.twa_succ_iterator_acc)

# Register twa_succ_iterator in _impl:
_impl.twa_succ_iterator_swigregister(twa_succ_iterator)
class succ_iterator(object):
    r"""
    Helper structure to iterate over the successors of a
    state using the on-the-fly interface.

    This one emulates an STL-like iterator over the
    twa_succ_iterator interface.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, it):
        _impl.succ_iterator_swiginit(self, _impl.new_succ_iterator(it))
    __eq__ = _swig_new_instance_method(_impl.succ_iterator___eq__)
    __ne__ = _swig_new_instance_method(_impl.succ_iterator___ne__)
    __ref__ = _swig_new_instance_method(_impl.succ_iterator___ref__)
    __swig_destroy__ = _impl.delete_succ_iterator

# Register succ_iterator in _impl:
_impl.succ_iterator_swigregister(succ_iterator)
class twa(object):
    r"""
     Spot is centered around the 'twa' type.  This type and its
     cousins are listed in 'twa_essentials'.  This is an
     abstract interface.  Its implementations are either
     'twa_representation' or 'twa_on_the_fly_algorithms'.  Other
     algorithms that work on 'twa' are listed in 'twa_algorithms'.


     A Transition-based ω-Automaton.

     The acronym TωA stands for Transition-based ω-automaton.
     We may write it as TwA or twa, but never as TWA as the
     w is just a non-utf8 replacement for ω that should not be
     capitalized.

     TωAs are transition-based automata, meaning that not-only do
     they have labels on edges, but they also have an acceptance
     condition defined in terms of sets of transitions.  The
     acceptance condition can be anything supported by the HOA format
     (http://adl.github.io/hoaf/).  The only restriction w.r.t. the
     format is that this class does not support alternating automata.

     Previous versions of Spot supported a type of automata called
     TGBA, which are TωA in which the acceptance condition is a set
     of sets of transitions that must be visited infinitely often.

     In this version, TGBAs are now represented by TωAs for which

         aut->acc().is_generalized_buchi()

     returns true.

     Browsing a TωA is usually achieved using two methods:
    ``get_init_state()``, and succ().  The former returns the initial
     state while the latter allows iterating over the outgoing edges
     of any given state. A TωA is always assumed to have at least
     one state, the initial one.

     Note that although this is a transition-based automaton, we never
     represent edges in the API.  Information about edges can be
     obtained by querying the iterator over the successors of a
     state.

     The interface presented here is what we call the on-the-fly
     interface of automata, because the TωA class can be subclassed
     to implement an object that computes its successors on-the-fly.
     The down-side is that all these methods are virtual, so you
     pay the cost of virtual calls when iterating over automata
     constructed on-the-fly.  Also the interface assumes that each
     successor state is a new object whose memory management is the
     responsibility of the caller, who should then call
     state::destroy() to release it.

     If you want to work with a TωA that is explicitly stored as a
     graph in memory, use the 'twa_graph' subclass instead.  A
     twa_graph object can be used as a twa (using the
     on-the-fly interface, even though nothing needs to be
     constructed), but it also offers a faster interface that does not
     use virtual methods.
    """

    thisown = 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
    get_init_state = _swig_new_instance_method(_impl.twa_get_init_state)
    succ_iter = _swig_new_instance_method(_impl.twa_succ_iter)
    release_iter = _swig_new_instance_method(_impl.twa_release_iter)
    get_dict = _swig_new_instance_method(_impl.twa_get_dict)
    register_ap = _swig_new_instance_method(_impl.twa_register_ap)
    unregister_ap = _swig_new_instance_method(_impl.twa_unregister_ap)
    register_aps_from_dict = _swig_new_instance_method(_impl.twa_register_aps_from_dict)
    ap = _swig_new_instance_method(_impl.twa_ap)
    ap_vars = _swig_new_instance_method(_impl.twa_ap_vars)
    format_state = _swig_new_instance_method(_impl.twa_format_state)
    project_state = _swig_new_instance_method(_impl.twa_project_state)
    acc = _swig_new_instance_method(_impl.twa_acc)
    is_empty = _swig_new_instance_method(_impl.twa_is_empty)
    accepting_run = _swig_new_instance_method(_impl.twa_accepting_run)
    accepting_word = _swig_new_instance_method(_impl.twa_accepting_word)
    intersects = _swig_new_instance_method(_impl.twa_intersects)
    intersecting_run = _swig_new_instance_method(_impl.twa_intersecting_run)
    intersecting_word = _swig_new_instance_method(_impl.twa_intersecting_word)
    exclusive_run = _swig_new_instance_method(_impl.twa_exclusive_run)
    exclusive_word = _swig_new_instance_method(_impl.twa_exclusive_word)
    num_sets = _swig_new_instance_method(_impl.twa_num_sets)
    get_acceptance = _swig_new_instance_method(_impl.twa_get_acceptance)
    set_acceptance = _swig_new_instance_method(_impl.twa_set_acceptance)
    copy_acceptance_of = _swig_new_instance_method(_impl.twa_copy_acceptance_of)
    copy_ap_of = _swig_new_instance_method(_impl.twa_copy_ap_of)
    copy_named_properties_of = _swig_new_instance_method(_impl.twa_copy_named_properties_of)
    set_generalized_buchi = _swig_new_instance_method(_impl.twa_set_generalized_buchi)
    set_generalized_co_buchi = _swig_new_instance_method(_impl.twa_set_generalized_co_buchi)
    set_buchi = _swig_new_instance_method(_impl.twa_set_buchi)
    set_co_buchi = _swig_new_instance_method(_impl.twa_set_co_buchi)
    release_named_properties = _swig_new_instance_method(_impl.twa_release_named_properties)
    prop_state_acc = _swig_new_instance_method(_impl.twa_prop_state_acc)
    is_sba = _swig_new_instance_method(_impl.twa_is_sba)
    prop_inherently_weak = _swig_new_instance_method(_impl.twa_prop_inherently_weak)
    prop_terminal = _swig_new_instance_method(_impl.twa_prop_terminal)
    prop_weak = _swig_new_instance_method(_impl.twa_prop_weak)
    prop_very_weak = _swig_new_instance_method(_impl.twa_prop_very_weak)
    prop_complete = _swig_new_instance_method(_impl.twa_prop_complete)
    prop_universal = _swig_new_instance_method(_impl.twa_prop_universal)
    prop_unambiguous = _swig_new_instance_method(_impl.twa_prop_unambiguous)
    prop_semi_deterministic = _swig_new_instance_method(_impl.twa_prop_semi_deterministic)
    prop_stutter_invariant = _swig_new_instance_method(_impl.twa_prop_stutter_invariant)
    prop_copy = _swig_new_instance_method(_impl.twa_prop_copy)
    prop_keep = _swig_new_instance_method(_impl.twa_prop_keep)
    prop_reset = _swig_new_instance_method(_impl.twa_prop_reset)
    set_name = _swig_new_instance_method(_impl.twa_set_name)
    get_name = _swig_new_instance_method(_impl.twa_get_name)
    set_state_names = _swig_new_instance_method(_impl.twa_set_state_names)
    get_state_names = _swig_new_instance_method(_impl.twa_get_state_names)
    set_product_states = _swig_new_instance_method(_impl.twa_set_product_states)
    get_product_states = _swig_new_instance_method(_impl.twa_get_product_states)
    get_original_states = _swig_new_instance_method(_impl.twa_get_original_states)
    get_original_classes = _swig_new_instance_method(_impl.twa_get_original_classes)
    highlight_state = _swig_new_instance_method(_impl.twa_highlight_state)
    get_highlight_state = _swig_new_instance_method(_impl.twa_get_highlight_state)
    remove_highlight_states = _swig_new_instance_method(_impl.twa_remove_highlight_states)
    highlight_edge = _swig_new_instance_method(_impl.twa_highlight_edge)
    get_highlight_edge = _swig_new_instance_method(_impl.twa_get_highlight_edge)
    remove_highlight_edges = _swig_new_instance_method(_impl.twa_remove_highlight_edges)

# Register twa in _impl:
_impl.twa_swigregister(twa)
class twa_prop_set(object):
    r"""
     A structure for selecting a set of automaton properties
     to copy.

     When an algorithm copies an automaton before making some
     modification on that automaton, it should use a ``prop_set``
     structure to indicate which properties should be copied from
     the original automaton.

     This structure does not list all supported properties, because
     properties are copied by groups of related properties.  For
     instance if an algorithm breaks the "inherent_weak"
     properties, it usually also breaks the "weak" and "terminal"
     properties.

     Set the flags to true to copy the value of the original
     property, and to false to ignore the original property
     (leaving the property of the new automaton to its default
     value, which is trival::maybe()).

     This can be used for instance as:

     .. code-block:: c++

            aut->prop_copy(other_aut, {true, false, false, false, false, true});
     This would copy the "state-based acceptance" and
     "stutter invariant" properties from ``other_aut`` to ``aut``.

     There are two flags for the determinism.  If
    ``deterministic`` is set, the universal, semi-deterministic,
     and unambiguous properties are copied as-is.  If deterministic
     is unset but improve_det is set, then those properties are
     only copied if they are positive.

     The reason there is no default value for these flags is that
     whenever we add a new property that does not fall into any of
     these groups, we will be forced to review all algorithms to
     decide if the property should be preserved or not.

     See also: make_twa_graph_ptr
     See also: prop_copy
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    state_based = property(_impl.twa_prop_set_state_based_get, _impl.twa_prop_set_state_based_set, doc=r"""preserve state-based acceptance""")
    inherently_weak = property(_impl.twa_prop_set_inherently_weak_get, _impl.twa_prop_set_inherently_weak_set, doc=r"""preserve inherently weak, weak, & terminal""")
    deterministic = property(_impl.twa_prop_set_deterministic_get, _impl.twa_prop_set_deterministic_set, doc=r"""preserve deterministic, semi-det, unambiguous""")
    improve_det = property(_impl.twa_prop_set_improve_det_get, _impl.twa_prop_set_improve_det_set, doc=r"""improve deterministic, semi-det, unambiguous""")
    complete = property(_impl.twa_prop_set_complete_get, _impl.twa_prop_set_complete_set, doc=r"""preserve completeness""")
    stutter_inv = property(_impl.twa_prop_set_stutter_inv_get, _impl.twa_prop_set_stutter_inv_set, doc=r"""preserve stutter invariance""")

    def __init__(self, *args):
        r"""
        *Overload 1:*
        Construct a prop_set with all flags set to false.

        |

        *Overload 2:*
        Construct a prop_set with explicit flag values.

        :type state_based: boolean
        :param state_based:    preserve state-based acceptance
        :type inherently_weak: boolean
        :param inherently_weak: preserve inherently weak, weak,
                                   and terminal
        :type deterministic: boolean
        :param deterministic:  preserve deterministic, semi-det,
                                   unambiguous
        :type improve_det: boolean
        :param improve_det:    improve deterministic, semi-det,
                                   unambiguous
        :type complete: boolean
        :param complete:       preserve completeness
        :type stutter_inv: boolean
        :param stutter_inv:    preserve stutter invariance
        """
        _impl.twa_prop_set_swiginit(self, _impl.new_twa_prop_set(*args))
    all = _swig_new_static_method(_impl.twa_prop_set_all)
    __swig_destroy__ = _impl.delete_twa_prop_set

# Register twa_prop_set in _impl:
_impl.twa_prop_set_swigregister(twa_prop_set)
create_atomic_prop_set = _impl.create_atomic_prop_set
atomic_prop_collect = _impl.atomic_prop_collect
atomic_prop_collect_as_bdd = _impl.atomic_prop_collect_as_bdd
collect_literals = _impl.collect_literals
collect_aps_with_polarities = _impl.collect_aps_with_polarities
collect_apids_with_polarities = _impl.collect_apids_with_polarities
collect_equivalent_literals = _impl.collect_equivalent_literals
class realizability_simplifier_base(object):
    r"""Simplify a reactive specification, preserving realizability"""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    polarity = _impl.realizability_simplifier_base_polarity
    r"""remove APs with single polarity"""
    global_equiv = _impl.realizability_simplifier_base_global_equiv
    r"""remove equivalent APs (Mealy semantics)"""
    global_equiv_output_only = _impl.realizability_simplifier_base_global_equiv_output_only
    r"""
    likewise, but don't consider equivalent input and
    output (Mealy semantics)
    """
    global_equiv_moore = _impl.realizability_simplifier_base_global_equiv_moore
    r"""remove equivalent APs (Moore semantics)"""

    def __init__(self, *args):
        r"""Build a realizability simplifier."""
        _impl.realizability_simplifier_base_swiginit(self, _impl.new_realizability_simplifier_base(*args))
    __swig_destroy__ = _impl.delete_realizability_simplifier_base
    simplify = _swig_new_instance_method(_impl.realizability_simplifier_base_simplify)

# Register realizability_simplifier_base in _impl:
_impl.realizability_simplifier_base_swigregister(realizability_simplifier_base)
class realizability_simplifier(realizability_simplifier_base):
    r"""Simplify a reactive specification, preserving realizability"""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""Build a realizability simplifier."""
        _impl.realizability_simplifier_swiginit(self, _impl.new_realizability_simplifier(*args))
    simplified_formula = _swig_new_instance_method(_impl.realizability_simplifier_simplified_formula)
    get_mapping = _swig_new_instance_method(_impl.realizability_simplifier_get_mapping)
    merge_mapping = _swig_new_instance_method(_impl.realizability_simplifier_merge_mapping)
    patch_mealy = _swig_new_instance_method(_impl.realizability_simplifier_patch_mealy)
    patch_game = _swig_new_instance_method(_impl.realizability_simplifier_patch_game)
    __swig_destroy__ = _impl.delete_realizability_simplifier

# Register realizability_simplifier in _impl:
_impl.realizability_simplifier_swigregister(realizability_simplifier)
collect_quantified_apids = _impl.collect_quantified_apids
class language_containment_checker(object):
    r"""Check containment between LTL formulas."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        This class uses an LTL-to-TGBA translation to translate LTL
        formulas.  See that function for the meaning of these options.
        """
        _impl.language_containment_checker_swiginit(self, _impl.new_language_containment_checker(*args))
    __swig_destroy__ = _impl.delete_language_containment_checker
    clear = _swig_new_instance_method(_impl.language_containment_checker_clear)
    contained = _swig_new_instance_method(_impl.language_containment_checker_contained)
    neg_contained = _swig_new_instance_method(_impl.language_containment_checker_neg_contained)
    contained_neg = _swig_new_instance_method(_impl.language_containment_checker_contained_neg)
    equal = _swig_new_instance_method(_impl.language_containment_checker_equal)

# Register language_containment_checker in _impl:
_impl.language_containment_checker_swigregister(language_containment_checker)
print_dot_psl = _impl.print_dot_psl
negative_normal_form = _impl.negative_normal_form
suffix_operator_normal_form = _impl.suffix_operator_normal_form
print_psl = _impl.print_psl
str_psl = _impl.str_psl
print_utf8_psl = _impl.print_utf8_psl
str_utf8_psl = _impl.str_utf8_psl
print_sere = _impl.print_sere
str_sere = _impl.str_sere
print_utf8_sere = _impl.print_utf8_sere
str_utf8_sere = _impl.str_utf8_sere
print_spin_ltl = _impl.print_spin_ltl
str_spin_ltl = _impl.str_spin_ltl
print_wring_ltl = _impl.print_wring_ltl
str_wring_ltl = _impl.str_wring_ltl
print_latex_psl = _impl.print_latex_psl
str_latex_psl = _impl.str_latex_psl
print_latex_sere = _impl.print_latex_sere
str_latex_sere = _impl.str_latex_sere
print_sclatex_psl = _impl.print_sclatex_psl
str_sclatex_psl = _impl.str_sclatex_psl
print_sclatex_sere = _impl.print_sclatex_sere
str_sclatex_sere = _impl.str_sclatex_sere
print_lbt_ltl = _impl.print_lbt_ltl
str_lbt_ltl = _impl.str_lbt_ltl
class tl_simplifier_options(object):
    r"""
    Options controlling which simplification passes the tl_simplifier
    applies.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        *Overload 1:*
        Construct with individual option flags.

        |

        *Overload 2:*
        Construct from a simplification level (0–3).

        Level 0: no simplification; level 1: basics + event_univ;
        level 2: + synt_impl; level 3: + containment checks.
        """
        _impl.tl_simplifier_options_swiginit(self, _impl.new_tl_simplifier_options(*args))
    reduce_basics = property(_impl.tl_simplifier_options_reduce_basics_get, _impl.tl_simplifier_options_reduce_basics_set, doc=r"""Enable basic rewriting rules.""")
    synt_impl = property(_impl.tl_simplifier_options_synt_impl_get, _impl.tl_simplifier_options_synt_impl_set, doc=r"""Enable syntactic implication simplifications.""")
    event_univ = property(_impl.tl_simplifier_options_event_univ_get, _impl.tl_simplifier_options_event_univ_set, doc=r"""Enable eventuality/universality reductions.""")
    containment_checks = property(_impl.tl_simplifier_options_containment_checks_get, _impl.tl_simplifier_options_containment_checks_set, doc=r"""Enable language containment checks.""")
    containment_checks_stronger = property(_impl.tl_simplifier_options_containment_checks_stronger_get, _impl.tl_simplifier_options_containment_checks_stronger_set, doc=r"""Enable stronger containment checks.""")
    nenoform_stop_on_boolean = property(_impl.tl_simplifier_options_nenoform_stop_on_boolean_get, _impl.tl_simplifier_options_nenoform_stop_on_boolean_set, doc=r"""
    If true, Boolean subformulae will not be put into
    negative normal form.
    """)
    reduce_size_strictly = property(_impl.tl_simplifier_options_reduce_size_strictly_get, _impl.tl_simplifier_options_reduce_size_strictly_set, doc=r"""
    If true, some rules that produce slightly larger formulas
    will be disabled.  Those larger formulas are normally easier
    to translate, so we recommend to set this to false.
    """)
    boolean_to_isop = property(_impl.tl_simplifier_options_boolean_to_isop_get, _impl.tl_simplifier_options_boolean_to_isop_set, doc=r"""If true, Boolean subformulae will be rewritten in ISOP form.""")
    favor_event_univ = property(_impl.tl_simplifier_options_favor_event_univ_get, _impl.tl_simplifier_options_favor_event_univ_set, doc=r"""Try to isolate subformulae that are eventual and universal.""")
    keep_top_xor = property(_impl.tl_simplifier_options_keep_top_xor_get, _impl.tl_simplifier_options_keep_top_xor_set, doc=r"""
    Keep Xor and Equiv at the top of the formula, possibly under
    &,|, and X operators.  Only rewrite Xor and Equiv under
    temporal operators.
    """)
    unit_prop = property(_impl.tl_simplifier_options_unit_prop_get, _impl.tl_simplifier_options_unit_prop_set, doc=r"""
    Enable unit-propagation-based simplification (see
    spot::unit_propagate) as a first pass before recursive
    rewriting.
    """)
    containment_max_states = property(_impl.tl_simplifier_options_containment_max_states_get, _impl.tl_simplifier_options_containment_max_states_set, doc=r"""
    If greater than 0, bound the number of states used by automata
    in containment checks.
    """)
    containment_max_ops = property(_impl.tl_simplifier_options_containment_max_ops_get, _impl.tl_simplifier_options_containment_max_ops_set, doc=r"""
    If greater than 0, maximal number of terms in a multop to perform
    containment checks on this multop.
    """)
    is_enabled = _swig_new_instance_method(_impl.tl_simplifier_options_is_enabled)
    save_to_option_map = _swig_new_instance_method(_impl.tl_simplifier_options_save_to_option_map)
    load_from_option_map = _swig_new_instance_method(_impl.tl_simplifier_options_load_from_option_map)
    __swig_destroy__ = _impl.delete_tl_simplifier_options

# Register tl_simplifier_options in _impl:
_impl.tl_simplifier_options_swigregister(tl_simplifier_options)
class tl_simplifier(object):
    r"""Rewrite or simplify *f* in various ways."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        *Overload 1:*
        Construct with default options and given BDD dictionary.

        |

        *Overload 2:*
        Construct with given options and BDD dictionary.

        |

        *Overload 3:*
        Construct with given options and BDD dictionary.
        """
        _impl.tl_simplifier_swiginit(self, _impl.new_tl_simplifier(*args))
    __swig_destroy__ = _impl.delete_tl_simplifier
    simplify = _swig_new_instance_method(_impl.tl_simplifier_simplify)
    negative_normal_form = _swig_new_instance_method(_impl.tl_simplifier_negative_normal_form)
    syntactic_implication = _swig_new_instance_method(_impl.tl_simplifier_syntactic_implication)
    syntactic_implication_neg = _swig_new_instance_method(_impl.tl_simplifier_syntactic_implication_neg)
    are_equivalent = _swig_new_instance_method(_impl.tl_simplifier_are_equivalent)
    implication = _swig_new_instance_method(_impl.tl_simplifier_implication)
    as_bdd = _swig_new_instance_method(_impl.tl_simplifier_as_bdd)
    clear_as_bdd_cache = _swig_new_instance_method(_impl.tl_simplifier_clear_as_bdd_cache)
    clear_caches = _swig_new_instance_method(_impl.tl_simplifier_clear_caches)
    get_dict = _swig_new_instance_method(_impl.tl_simplifier_get_dict)
    star_normal_form = _swig_new_instance_method(_impl.tl_simplifier_star_normal_form)
    boolean_to_isop = _swig_new_instance_method(_impl.tl_simplifier_boolean_to_isop)
    print_stats = _swig_new_instance_method(_impl.tl_simplifier_print_stats)

# Register tl_simplifier in _impl:
_impl.tl_simplifier_swigregister(tl_simplifier)
normalize_quantifiers = _impl.normalize_quantifiers
to_delta2 = _impl.to_delta2
distribute_next = _impl.distribute_next
class unabbreviator(object):
    r"""
    Clone and rewrite a formula to remove specified operators
    logical operators.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Constructor

        The set of operators to remove should be passed as a string
        in which each letter denotes an operator (using LBT's
        convention).
        """
        _impl.unabbreviator_swiginit(self, _impl.new_unabbreviator(*args))
    run = _swig_new_instance_method(_impl.unabbreviator_run)
    __swig_destroy__ = _impl.delete_unabbreviator

# Register unabbreviator in _impl:
_impl.unabbreviator_swigregister(unabbreviator)
cvar = _impl.cvar
default_unabbrev_string = cvar.default_unabbrev_string

unabbreviate = _impl.unabbreviate
class random_formula(object):
    r"""Base class for random formula generators"""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, proba_size, ap, output_ap=None, is_output=0):
        r"""
        Construct with *proba_size* operator slots
        and atomic propositions *ap*.
        """
        _impl.random_formula_swiginit(self, _impl.new_random_formula(proba_size, ap, output_ap, is_output))
    __swig_destroy__ = _impl.delete_random_formula
    ap = _swig_new_instance_method(_impl.random_formula_ap)
    output_ap = _swig_new_instance_method(_impl.random_formula_output_ap)
    is_output_fun = _swig_new_instance_method(_impl.random_formula_is_output_fun)
    patterns = _swig_new_instance_method(_impl.random_formula_patterns)
    draw_literals = _swig_new_instance_method(_impl.random_formula_draw_literals)
    generate = _swig_new_instance_method(_impl.random_formula_generate)
    dump_priorities = _swig_new_instance_method(_impl.random_formula_dump_priorities)
    parse_options = _swig_new_instance_method(_impl.random_formula_parse_options)
    has_unary_ops = _swig_new_instance_method(_impl.random_formula_has_unary_ops)

# Register random_formula in _impl:
_impl.random_formula_swigregister(random_formula)
class random_ltl(random_formula):
    r"""
    Generate random LTL formulas.

    This class recursively constructs LTL formulas of a given
    size.  The formulas will use atomic propositions from
    the set of propositions passed to the constructor, in addition
    to the constant and all LTL operators supported by Spot.

    By default each operator has equal chance to be selected.
    Also, each atomic proposition has as much chance as each
    constant (i.e., true and false) to be picked.  This can be
    tuned using parse_options().
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, ap, output_ap=None, is_output=0, subformulas=None):
        r"""
        Create a random LTL generator using atomic propositions from *ap*.

        The default priorities are defined as follows, depending on the
        presence of *subformulas*.
                 ap      n              sub     n
               false   1              false   1
               true    1              true    1
               not     1              not     1
               F       1              F       1
               G       1              G       1
               X       1              X       1
               strongX 0              strongX 0
               equiv   1              equiv   1
               implies 1              implies 1
               xor     1              xor     1
               R       1              R       1
               U       1              U       1
               W       1              W       1
               M       1              M       1
               and     1              and     1
               or      1              or      1

        Where ``n`` is the number of atomic propositions in the
        set passed to the constructor.

        This means that each operator has equal chance to be
        selected.  Also, each atomic proposition has as much chance
        as each constant (i.e., true and false) to be picked.

        These priorities can be changed using the parse_options method.

        If a set of subformulas is passed to the constructor, the generator
        will build a Boolean formulas using patterns as atoms.  Atomic
        propositions in patterns will be rewritten randomly by drawing
        some from *ap*.  The probability of false/true to be generated
        default to 0 in this case.
        """
        _impl.random_ltl_swiginit(self, _impl.new_random_ltl(ap, output_ap, is_output, subformulas))
    __swig_destroy__ = _impl.delete_random_ltl

# Register random_ltl in _impl:
_impl.random_ltl_swigregister(random_ltl)
class random_boolean(random_formula):
    r"""
    Generate random Boolean formulas.

    This class recursively constructs Boolean formulas of a given size.
    The formulas will use atomic propositions from the
    set of propositions passed to the constructor, in addition to the
    constant and all Boolean operators supported by Spot.

    By default each operator has equal chance to be selected.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, ap, output_ap=None, is_output=0, subformulas=None):
        r"""
        Create a random Boolean formula generator using atomic
        propositions from *ap*.

        The default priorities are defined as follows depending on
        the presence of *subformulas*.
                 ap      n         sub     n
               false   1         false   0
               true    1         true    0
               not     1         not     1
               equiv   1         equiv   1
               implies 1         implies 1
               xor     1         xor     1
               and     1         and     1
               or      1         or      1

        Where ``n`` is the number of atomic propositions in the
        set passed to the constructor.

        This means that each operator has equal chance to be
        selected.  Also, each atomic proposition has as much chance
        as each constant (i.e., true and false) to be picked.

        These priorities can be changed using the parse_options method.

        If a set of *subformulas* is passed to the constructor, the
        generator will build a Boolean formulas using patterns as
        atoms.  Atomic propositions in patterns will be rewritten
        randomly by drawing some from *ap*.
        """
        _impl.random_boolean_swiginit(self, _impl.new_random_boolean(ap, output_ap, is_output, subformulas))
    __swig_destroy__ = _impl.delete_random_boolean

# Register random_boolean in _impl:
_impl.random_boolean_swigregister(random_boolean)
class random_sere(random_formula):
    r"""
    Generate random SERE.

    This class recursively constructs SERE of a given size.
    The formulas will use atomic propositions from the
    set of propositions passed to the constructor, in addition to the
    constant and all SERE operators supported by Spot.

    By default each operator has equal chance to be selected.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, ap):
        r"""
        Create a random SERE generator using atomic propositions from *ap*.

        The default priorities are defined as follows:
                 eword    1
               boolform 1
               star     1
               star_b   1
               equal_b  1
               goto_b   1
               and      1
               andNLM   1
               or       1
               concat   1
               fusion   1

        Where "boolfrom" designates a Boolean formula generated
        by random_boolean.

        These priorities can be changed using the parse_options method.

        In addition, you can set the properties of the Boolean
        formula generator used to build Boolean subformulas using
        the parse_options method of the ``rb`` attribute.
        """
        _impl.random_sere_swiginit(self, _impl.new_random_sere(ap))
    rb = property(_impl.random_sere_rb_get, _impl.random_sere_rb_set, doc=r"""The Boolean formula generator used to build Boolean sub-expressions.""")
    __swig_destroy__ = _impl.delete_random_sere

# Register random_sere in _impl:
_impl.random_sere_swigregister(random_sere)
class random_psl(random_ltl):
    r"""
    Generate random PSL formulas.

    This class recursively constructs PSL formulas of a given size.
    The formulas will use atomic propositions from the
    set of propositions passed to the constructor, in addition to the
    constant and all PSL operators supported by Spot.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, ap):
        r"""
        Create a random PSL generator using atomic propositions from *ap*.

        PSL formulas are built by combining LTL operators, plus
        three operators (EConcat, UConcat, Closure) taking a SERE
        as parameter.

        The default priorities are defined as follows:
                 ap      n
               false   1
               true    1
               not     1
               F       1
               G       1
               X       1
               Closure 1
               equiv   1
               implies 1
               xor     1
               R       1
               U       1
               W       1
               M       1
               and     1
               or      1
               EConcat 1
               UConcat 1

        Where ``n`` is the number of atomic propositions in the
        set passed to the constructor.

        This means that each operator has equal chance to be
        selected.  Also, each atomic proposition has as much chance
        as each constant (i.e., true and false) to be picked.

        These priorities can be changed using the parse_options method.

        In addition, you can set the properties of the SERE generator
        used to build SERE subformulas using the parse_options method
        of the ``rs`` attribute.
        """
        _impl.random_psl_swiginit(self, _impl.new_random_psl(ap))
    rs = property(_impl.random_psl_rs_get, _impl.random_psl_rs_set, doc=r"""The SERE generator used to generate SERE subformulas.""")
    __swig_destroy__ = _impl.delete_random_psl

# Register random_psl in _impl:
_impl.random_psl_swigregister(random_psl)
class randltlgenerator(object):
    r"""
    Generator of random LTL/PSL/SERE/Boolean formulas with configurable
    options.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Bool = _impl.randltlgenerator_Bool
    LTL = _impl.randltlgenerator_LTL
    SERE = _impl.randltlgenerator_SERE
    PSL = _impl.randltlgenerator_PSL
    MAX_TRIALS = _impl.randltlgenerator_MAX_TRIALS
    r"""Maximum number of attempts to generate a unique formula."""

    def __init__(self, *args):
        r"""
        *Overload 1:*
        Construct with *aprops_n* random atomic propositions.

        |

        *Overload 2:*
        Construct with an explicit set of atomic propositions.

        |

        *Overload 3:*
        Construct with an explicit set of atomic propositions.

        |

        *Overload 4:*
        Construct with an explicit set of atomic propositions.

        |

        *Overload 5:*
        Construct with an explicit set of atomic propositions.

        |

        *Overload 6:*
        Construct with an explicit set of atomic propositions.

        |

        *Overload 7:*
        Construct with an explicit set of atomic propositions.
        """
        _impl.randltlgenerator_swiginit(self, _impl.new_randltlgenerator(*args))
    __swig_destroy__ = _impl.delete_randltlgenerator
    next = _swig_new_instance_method(_impl.randltlgenerator_next)
    dump_ltl_priorities = _swig_new_instance_method(_impl.randltlgenerator_dump_ltl_priorities)
    dump_bool_priorities = _swig_new_instance_method(_impl.randltlgenerator_dump_bool_priorities)
    dump_psl_priorities = _swig_new_instance_method(_impl.randltlgenerator_dump_psl_priorities)
    dump_sere_priorities = _swig_new_instance_method(_impl.randltlgenerator_dump_sere_priorities)
    dump_sere_bool_priorities = _swig_new_instance_method(_impl.randltlgenerator_dump_sere_bool_priorities)
    remove_some_props = _swig_new_instance_method(_impl.randltlgenerator_remove_some_props)
    GF_n = _swig_new_instance_method(_impl.randltlgenerator_GF_n)

# Register randltlgenerator in _impl:
_impl.randltlgenerator_swigregister(randltlgenerator)
length = _impl.length
length_boolone = _impl.length_boolone
from_ltlf = _impl.from_ltlf
class ltlf_simplifier(object):
    r"""Cheap simplification rules for LTLf formulas."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""Build an LTLf simplifier."""
        _impl.ltlf_simplifier_swiginit(self, _impl.new_ltlf_simplifier())
    __swig_destroy__ = _impl.delete_ltlf_simplifier
    simplify = _swig_new_instance_method(_impl.ltlf_simplifier_simplify)

# Register ltlf_simplifier in _impl:
_impl.ltlf_simplifier_swigregister(ltlf_simplifier)
ltlf_one_step_sat_rewrite = _impl.ltlf_one_step_sat_rewrite
class ltlf_one_step_sat_rewrite_with_cache(object):
    r"""
    Cached version of the one-step satisfiability rewriting for LTLf
    formulas.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""Build the cache."""
        _impl.ltlf_one_step_sat_rewrite_with_cache_swiginit(self, _impl.new_ltlf_one_step_sat_rewrite_with_cache())
    __swig_destroy__ = _impl.delete_ltlf_one_step_sat_rewrite_with_cache
    rewrite = _swig_new_instance_method(_impl.ltlf_one_step_sat_rewrite_with_cache_rewrite)

# Register ltlf_one_step_sat_rewrite_with_cache in _impl:
_impl.ltlf_one_step_sat_rewrite_with_cache_swigregister(ltlf_one_step_sat_rewrite_with_cache)
ltlf_one_step_unsat_rewrite = _impl.ltlf_one_step_unsat_rewrite
class ltlf_one_step_unsat_rewrite_with_cache(object):
    r"""
    Cached version of the one-step unsatisfiability rewriting for LTLf
    formulas.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""Build the cache."""
        _impl.ltlf_one_step_unsat_rewrite_with_cache_swiginit(self, _impl.new_ltlf_one_step_unsat_rewrite_with_cache())
    __swig_destroy__ = _impl.delete_ltlf_one_step_unsat_rewrite_with_cache
    rewrite = _swig_new_instance_method(_impl.ltlf_one_step_unsat_rewrite_with_cache_rewrite)

# Register ltlf_one_step_unsat_rewrite_with_cache in _impl:
_impl.ltlf_one_step_unsat_rewrite_with_cache_swigregister(ltlf_one_step_unsat_rewrite_with_cache)
prcheck_Auto = _impl.prcheck_Auto
prcheck_via_CoBuchi = _impl.prcheck_via_CoBuchi
prcheck_via_Rabin = _impl.prcheck_via_Rabin
prcheck_via_Parity = _impl.prcheck_via_Parity
is_persistence = _impl.is_persistence
is_recurrence = _impl.is_recurrence
ocheck_Auto = _impl.ocheck_Auto
ocheck_via_CoBuchi = _impl.ocheck_via_CoBuchi
ocheck_via_Rabin = _impl.ocheck_via_Rabin
ocheck_via_WDBA = _impl.ocheck_via_WDBA
is_obligation = _impl.is_obligation
mp_class = _impl.mp_class
nesting_depth = _impl.nesting_depth
is_liveness = _impl.is_liveness
remove_x = _impl.remove_x
Abc = _impl.Abc
Pnn = _impl.Pnn
relabel = _impl.relabel
relabel_bse = _impl.relabel_bse
relabel_overlapping_bse = _impl.relabel_overlapping_bse
relabel_apply = _impl.relabel_apply
ltl_satisfiable = _impl.ltl_satisfiable
unit_propagate = _impl.unit_propagate
class taa_tgba(twa):
    r"""
    A self-loop Transition-based Alternating Automaton (TAA)
    which is seen as a TGBA (abstract class, see below).
    """

    thisown = 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
    add_condition = _swig_new_instance_method(_impl.taa_tgba_add_condition)
    __swig_destroy__ = _impl.delete_taa_tgba
    get_init_state = _swig_new_instance_method(_impl.taa_tgba_get_init_state)

# Register taa_tgba in _impl:
_impl.taa_tgba_swigregister(taa_tgba)
class set_state(state):
    r"""Set of states deriving from 'state'."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, s, delete_me=False):
        r"""
        Construct a set_state wrapping state set *s*.

        If *delete_me* is true the set pointed by *s* will be
        deleted when this state is destroyed.
        """
        _impl.set_state_swiginit(self, _impl.new_set_state(s, delete_me))
    clone = _swig_new_instance_method(_impl.set_state_clone)
    __swig_destroy__ = _impl.delete_set_state
    get_state = _swig_new_instance_method(_impl.set_state_get_state)

# Register set_state in _impl:
_impl.set_state_swigregister(set_state)
class taa_succ_iterator(twa_succ_iterator):
    r"""
    Successor iterator for alternating automata with tree-and-automata
    (TAA) transitions.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, s, acc):
        r"""Construct an iterator over the successors of state *s*."""
        _impl.taa_succ_iterator_swiginit(self, _impl.new_taa_succ_iterator(s, acc))
    __swig_destroy__ = _impl.delete_taa_succ_iterator
    dst = _swig_new_instance_method(_impl.taa_succ_iterator_dst)

# Register taa_succ_iterator in _impl:
_impl.taa_succ_iterator_swigregister(taa_succ_iterator)
class taa_tgba_string(taa_tgba):
    r"""A TAA-TGBA automaton where states are labelled with strings."""

    thisown = 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

# Register taa_tgba_string in _impl:
_impl.taa_tgba_string_swigregister(taa_tgba_string)
make_taa_tgba_string = _impl.make_taa_tgba_string
class taa_tgba_formula(taa_tgba):
    r"""A TAA-TGBA automaton where states are labelled with formulas."""

    thisown = 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

# Register taa_tgba_formula in _impl:
_impl.taa_tgba_formula_swigregister(taa_tgba_formula)
make_taa_tgba_formula = _impl.make_taa_tgba_formula
class state_product(state):
    r"""
    A state for 'twa_product'.

    This state is in fact a pair of state: the state from the left
    automaton and that of the right.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, left, right, pool):
        r"""
        Constructor
        :type left: :py:class:`state`
        :param left: The state from the left automaton.
        :type right: :py:class:`state`
        :param right: The state from the right automaton.
        :type pool: fixed_size_pool< pool_type::Safe >
        :param pool: The pool from which the state was allocated.
            These states are acquired by twa_product, and will
            be destroyed on destruction.
        """
        _impl.state_product_swiginit(self, _impl.new_state_product(left, right, pool))
    left = _swig_new_instance_method(_impl.state_product_left)
    right = _swig_new_instance_method(_impl.state_product_right)
    clone = _swig_new_instance_method(_impl.state_product_clone)

# Register state_product in _impl:
_impl.state_product_swigregister(state_product)
class twa_product(twa):
    r"""A lazy product.  (States are computed on the fly.)"""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, left, right):
        r"""
        Constructor.
        :type left: :py:class:`twa`
        :param left: The left automata in the product.
        :type right: :py:class:`twa`
        :param right: The right automata in the product.
            Do not be fooled by these arguments: a product is commutative.
        """
        _impl.twa_product_swiginit(self, _impl.new_twa_product(left, right))
    __swig_destroy__ = _impl.delete_twa_product
    left_acc = _swig_new_instance_method(_impl.twa_product_left_acc)
    right_acc = _swig_new_instance_method(_impl.twa_product_right_acc)

# Register twa_product in _impl:
_impl.twa_product_swigregister(twa_product)
class twa_product_init(twa_product):
    r"""A lazy product with different initial states."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, left, right, left_init, right_init):
        r"""
        Construct a product with explicit initial states.

        :type left: :py:class:`twa`
        :param left:       Left component automaton.
        :type right: :py:class:`twa`
        :param right:      Right component automaton.
        :type left_init: :py:class:`state`
        :param left_init:  Initial state of the left component.
        :type right_init: :py:class:`state`
        :param right_init: Initial state of the right component.
        """
        _impl.twa_product_init_swiginit(self, _impl.new_twa_product_init(left, right, left_init, right_init))
    __swig_destroy__ = _impl.delete_twa_product_init

# Register twa_product_init in _impl:
_impl.twa_product_init_swigregister(twa_product_init)
otf_product = _impl.otf_product
otf_product_at = _impl.otf_product_at
class const_universal_dests(object):
    thisown = 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))
    begin = _swig_new_instance_method(_impl.const_universal_dests_begin)
    end = _swig_new_instance_method(_impl.const_universal_dests_end)
    __iter__ = _swig_new_instance_method(_impl.const_universal_dests___iter__)
    __swig_destroy__ = _impl.delete_const_universal_dests

# Register const_universal_dests in _impl:
_impl.const_universal_dests_swigregister(const_universal_dests)
class twa_graph_state(state):
    r"""
    Graph-based representation of a TωA

    In a twa_graph, states are usually denoted by their number.  However
    if the on-the-fly interface is used, it returns pointer to instances
    of the twa_graph_state class.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""Copy constructor (no-op; graph states are identified by address)."""
        _impl.twa_graph_state_swiginit(self, _impl.new_twa_graph_state(*args))
    __swig_destroy__ = _impl.delete_twa_graph_state
    clone = _swig_new_instance_method(_impl.twa_graph_state_clone)

# Register twa_graph_state in _impl:
_impl.twa_graph_state_swigregister(twa_graph_state)
class twa_graph_edge_data(object):
    r"""
    Data attached to edges of a twa_graph

    Each edge of the graph has two additional data that are *cond*
    (a BDD representing the Boolean formula labeling the edge), and
    *acc* a set of acceptance marks representing the membership of
    the each to each acceptance set.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    cond = property(_impl.twa_graph_edge_data_cond_get, _impl.twa_graph_edge_data_cond_set, doc=r"""The Boolean formula labeling this edge.""")
    acc = property(_impl.twa_graph_edge_data_acc_get, _impl.twa_graph_edge_data_acc_set, doc=r"""The acceptance mark of this edge.""")

    def __init__(self, *args):
        r"""
        *Overload 1:*
        Construct an edge labeled with *cond* and acceptance mark *acc*.

        |

        *Overload 2:*
        Construct an edge labeled with *cond* and acceptance mark *acc*.
        """
        _impl.twa_graph_edge_data_swiginit(self, _impl.new_twa_graph_edge_data(*args))
    __lt__ = _swig_new_instance_method(_impl.twa_graph_edge_data___lt__)
    __eq__ = _swig_new_instance_method(_impl.twa_graph_edge_data___eq__)
    __swig_destroy__ = _impl.delete_twa_graph_edge_data

# Register twa_graph_edge_data in _impl:
_impl.twa_graph_edge_data_swigregister(twa_graph_edge_data)
class twa_graph(twa):
    r"""Graph-based representation of a TωA"""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        *Overload 1:*
        Construct an empty automaton using *dict* for BDD variables.

        |

        *Overload 2:*
        Copy another automaton, keeping only the properties in *p*.
        """
        _impl.twa_graph_swiginit(self, _impl.new_twa_graph(*args))
    __swig_destroy__ = _impl.delete_twa_graph
    get_graph = _swig_new_instance_method(_impl.twa_graph_get_graph)
    num_states = _swig_new_instance_method(_impl.twa_graph_num_states)
    num_edges = _swig_new_instance_method(_impl.twa_graph_num_edges)
    set_init_state = _swig_new_instance_method(_impl.twa_graph_set_init_state)
    get_init_state_number = _swig_new_instance_method(_impl.twa_graph_get_init_state_number)
    get_init_state = _swig_new_instance_method(_impl.twa_graph_get_init_state)
    is_univ_dest = _swig_new_static_method(_impl.twa_graph_is_univ_dest)
    state_number = _swig_new_instance_method(_impl.twa_graph_state_number)

    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)


    format_state = _swig_new_instance_method(_impl.twa_graph_format_state)
    edge_number = _swig_new_instance_method(_impl.twa_graph_edge_number)
    edge_data = _swig_new_instance_method(_impl.twa_graph_edge_data)
    edge_storage = _swig_new_instance_method(_impl.twa_graph_edge_storage)
    new_state = _swig_new_instance_method(_impl.twa_graph_new_state)
    new_states = _swig_new_instance_method(_impl.twa_graph_new_states)
    new_edge = _swig_new_instance_method(_impl.twa_graph_new_edge)
    new_acc_edge = _swig_new_instance_method(_impl.twa_graph_new_acc_edge)

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


    out_iteraser = _swig_new_instance_method(_impl.twa_graph_out_iteraser)
    univ_dests = _swig_new_instance_method(_impl.twa_graph_univ_dests)
    is_existential = _swig_new_instance_method(_impl.twa_graph_is_existential)
    edges = _swig_new_instance_method(_impl.twa_graph_edges)
    is_dead_edge = _swig_new_instance_method(_impl.twa_graph_is_dead_edge)
    merge_edges = _swig_new_instance_method(_impl.twa_graph_merge_edges)
    merge_univ_dests = _swig_new_instance_method(_impl.twa_graph_merge_univ_dests)
    merge_states = _swig_new_instance_method(_impl.twa_graph_merge_states)
    merge_states_of = _swig_new_instance_method(_impl.twa_graph_merge_states_of)
    purge_dead_states = _swig_new_instance_method(_impl.twa_graph_purge_dead_states)
    purge_unreachable_states = _swig_new_instance_method(_impl.twa_graph_purge_unreachable_states)
    remove_unused_ap = _swig_new_instance_method(_impl.twa_graph_remove_unused_ap)
    copy_state_names_from = _swig_new_instance_method(_impl.twa_graph_copy_state_names_from)

    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)


    __eq__ = _swig_new_instance_method(_impl.twa_graph___eq__)
    kill_state = _swig_new_instance_method(_impl.twa_graph_kill_state)
    dump_storage_as_dot = _swig_new_instance_method(_impl.twa_graph_dump_storage_as_dot)
    new_univ_edge = _swig_new_instance_method(_impl.twa_graph_new_univ_edge)
    set_univ_init_state = _swig_new_instance_method(_impl.twa_graph_set_univ_init_state)
    report_univ_dest = _swig_new_instance_method(_impl.twa_graph_report_univ_dest)

# Register twa_graph in _impl:
_impl.twa_graph_swigregister(twa_graph)
make_twa_graph = _impl.make_twa_graph
class twa_graph_state_out(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, g, t):
        _impl.twa_graph_state_out_swiginit(self, _impl.new_twa_graph_state_out(g, t))
    begin = _swig_new_instance_method(_impl.twa_graph_state_out_begin)
    end = _swig_new_instance_method(_impl.twa_graph_state_out_end)
    recycle = _swig_new_instance_method(_impl.twa_graph_state_out_recycle)
    __iter__ = _swig_new_instance_method(_impl.twa_graph_state_out___iter__)
    __swig_destroy__ = _impl.delete_twa_graph_state_out

# Register twa_graph_state_out in _impl:
_impl.twa_graph_state_out_swigregister(twa_graph_state_out)
class twa_graph_killer_edge_iterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, g, t, src):
        _impl.twa_graph_killer_edge_iterator_swiginit(self, _impl.new_twa_graph_killer_edge_iterator(g, t, src))
    erase = _swig_new_instance_method(_impl.twa_graph_killer_edge_iterator_erase)
    current = _swig_new_instance_method(_impl.twa_graph_killer_edge_iterator_current)
    advance = _swig_new_instance_method(_impl.twa_graph_killer_edge_iterator_advance)
    __bool__ = _swig_new_instance_method(_impl.twa_graph_killer_edge_iterator___bool__)
    __swig_destroy__ = _impl.delete_twa_graph_killer_edge_iterator

# Register twa_graph_killer_edge_iterator in _impl:
_impl.twa_graph_killer_edge_iterator_swigregister(twa_graph_killer_edge_iterator)
class twa_graph_all_trans(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, tv):
        _impl.twa_graph_all_trans_swiginit(self, _impl.new_twa_graph_all_trans(tv))
    begin = _swig_new_instance_method(_impl.twa_graph_all_trans_begin)
    end = _swig_new_instance_method(_impl.twa_graph_all_trans_end)
    __iter__ = _swig_new_instance_method(_impl.twa_graph_all_trans___iter__)
    __swig_destroy__ = _impl.delete_twa_graph_all_trans

# Register twa_graph_all_trans in _impl:
_impl.twa_graph_all_trans_swigregister(twa_graph_all_trans)
class twa_graph_edge_boxed_data(twa_graph_edge_data):
    thisown = 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())
    data = _swig_new_instance_method(_impl.twa_graph_edge_boxed_data_data)
    __swig_destroy__ = _impl.delete_twa_graph_edge_boxed_data

# Register twa_graph_edge_boxed_data in _impl:
_impl.twa_graph_edge_boxed_data_swigregister(twa_graph_edge_boxed_data)
class twa_graph_edge_storage(twa_graph_edge_boxed_data):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    dst = property(_impl.twa_graph_edge_storage_dst_get, _impl.twa_graph_edge_storage_dst_set)
    next_succ = property(_impl.twa_graph_edge_storage_next_succ_get, _impl.twa_graph_edge_storage_next_succ_set)
    src = 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())
    __lt__ = _swig_new_instance_method(_impl.twa_graph_edge_storage___lt__)
    __eq__ = _swig_new_instance_method(_impl.twa_graph_edge_storage___eq__)
    __swig_destroy__ = _impl.delete_twa_graph_edge_storage

# Register twa_graph_edge_storage in _impl:
_impl.twa_graph_edge_storage_swigregister(twa_graph_edge_storage)
class aig(object):
    r"""
    A class representing AIG circuits

    AIG circuits consist of (named) inputs, (named) outputs, latches which
    serve as memory, and gates and negations connecting them.
    AIG circuits can be used to represent controllers, which is currently
    their sole purpose within spot.
    AIGs produce an output sequence based on the following rules:
    1) All latches are initialized to 0
    2) The next input is read.
    3) The output and the state of the latches for the next turn
       are given by the gates as a function of the current latches and inputs
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        *Overload 1:*
        Constructing an "empty" aig, knowing only about the
               necessary inputs, outputs and latches. A bdd_dict can
               be handed to the circuit in order to allow for verification
               against other automata after construction

        |

        *Overload 2:*
        Constructing the circuit with generic names.

        |

        *Overload 3:*
        Constructing the circuit with generic names.
        """
        _impl.aig_swiginit(self, _impl.new_aig(*args))
    __swig_destroy__ = _impl.delete_aig
    get_safe_point_ = _swig_new_instance_method(_impl.aig_get_safe_point_)
    roll_back_ = _swig_new_instance_method(_impl.aig_roll_back_)
    reapply_ = _swig_new_instance_method(_impl.aig_reapply_)
    num_outputs = _swig_new_instance_method(_impl.aig_num_outputs)
    outputs = _swig_new_instance_method(_impl.aig_outputs)
    output = _swig_new_instance_method(_impl.aig_output)
    output_names = _swig_new_instance_method(_impl.aig_output_names)
    num_inputs = _swig_new_instance_method(_impl.aig_num_inputs)
    input_names = _swig_new_instance_method(_impl.aig_input_names)
    num_latches = _swig_new_instance_method(_impl.aig_num_latches)
    next_latches = _swig_new_instance_method(_impl.aig_next_latches)
    num_gates = _swig_new_instance_method(_impl.aig_num_gates)
    gates = _swig_new_instance_method(_impl.aig_gates)
    max_var = _swig_new_instance_method(_impl.aig_max_var)
    input_var = _swig_new_instance_method(_impl.aig_input_var)
    input_bdd = _swig_new_instance_method(_impl.aig_input_bdd)
    latch_var = _swig_new_instance_method(_impl.aig_latch_var)
    latch_bdd = _swig_new_instance_method(_impl.aig_latch_bdd)
    gate_var = _swig_new_instance_method(_impl.aig_gate_var)
    gate_bdd = _swig_new_instance_method(_impl.aig_gate_bdd)
    aigvar2bdd = _swig_new_instance_method(_impl.aig_aigvar2bdd)
    bdd2aigvar = _swig_new_instance_method(_impl.aig_bdd2aigvar)
    bdd2INFvar = _swig_new_instance_method(_impl.aig_bdd2INFvar)
    bdd2ISOPvar = _swig_new_instance_method(_impl.aig_bdd2ISOPvar)
    encode_bdd = _swig_new_instance_method(_impl.aig_encode_bdd)
    set_output = _swig_new_instance_method(_impl.aig_set_output)
    set_next_latch = _swig_new_instance_method(_impl.aig_set_next_latch)
    aig_true = _swig_new_static_method(_impl.aig_aig_true)
    aig_false = _swig_new_static_method(_impl.aig_aig_false)
    aig_not = _swig_new_instance_method(_impl.aig_aig_not)
    aig_and = _swig_new_instance_method(_impl.aig_aig_and)
    aig_or = _swig_new_instance_method(_impl.aig_aig_or)
    aig_pos = _swig_new_instance_method(_impl.aig_aig_pos)
    encode_all_bdds = _swig_new_instance_method(_impl.aig_encode_all_bdds)
    parse_aag = _swig_new_static_method(_impl.aig_parse_aag)
    as_automaton = _swig_new_instance_method(_impl.aig_as_automaton)
    circ_state = _swig_new_instance_method(_impl.aig_circ_state)
    circ_state_of = _swig_new_instance_method(_impl.aig_circ_state_of)
    circ_init = _swig_new_instance_method(_impl.aig_circ_init)
    circ_step = _swig_new_instance_method(_impl.aig_circ_step)

# Register aig in _impl:
_impl.aig_swigregister(aig)
mealy_machine_to_aig = _impl.mealy_machine_to_aig
mealy_machines_to_aig = _impl.mealy_machines_to_aig
print_aiger = _impl.print_aiger
class outedge_combiner(object):
    r"""
    Helper class to combine outgoing edges in alternating
    automata

    The idea is that you can call the operator() on some state to get a
    BDD representation of its outgoing edges (labels and
    destinations, but not acceptance marks).  The BDD representation
    of different states can be combined using & or | to build a new
    representation of some outgoing edges that can be attached to
    some state with new_dests.  The use of BDDs helps removing
    superfluous edges.

    Beware that new_dests() just *appends* the transitions to the
    supplied state, it does not remove existing ones.

    operator() can be called on states with universal branching
    (that's actually the point), and can be called on state number
    that designate groups of destination states (in that case the
    conjunction of all those states are taken).
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, aut):
        r"""Construct from an alternating automaton."""
        _impl.outedge_combiner_swiginit(self, _impl.new_outedge_combiner(aut))
    __swig_destroy__ = _impl.delete_outedge_combiner
    __call__ = _swig_new_instance_method(_impl.outedge_combiner___call__)
    new_dests = _swig_new_instance_method(_impl.outedge_combiner_new_dests)

# Register outedge_combiner in _impl:
_impl.outedge_combiner_swigregister(outedge_combiner)
remove_alternation = _impl.remove_alternation
class univ_remover_state(state):
    r"""
    State used during on-the-fly removal of universal edges from an
    alternating automaton.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        *Overload 1:*
        Construct a state from a set of original states.

        |

        *Overload 2:*
        Copy constructor.
        """
        _impl.univ_remover_state_swiginit(self, _impl.new_univ_remover_state(*args))
    states = _swig_new_instance_method(_impl.univ_remover_state_states)
    is_reset = _swig_new_instance_method(_impl.univ_remover_state_is_reset)
    __swig_destroy__ = _impl.delete_univ_remover_state

# Register univ_remover_state in _impl:
_impl.univ_remover_state_swigregister(univ_remover_state)
class twa_univ_remover(twa):
    r"""
    On-the-fly TωA that removes universal edges from an alternating
    automaton.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, aut):
        r"""Construct from an alternating automaton."""
        _impl.twa_univ_remover_swiginit(self, _impl.new_twa_univ_remover(aut))
    allocate_state_vars = _swig_new_instance_method(_impl.twa_univ_remover_allocate_state_vars)
    __swig_destroy__ = _impl.delete_twa_univ_remover

# Register twa_univ_remover in _impl:
_impl.twa_univ_remover_swigregister(twa_univ_remover)
remove_univ_otf = _impl.remove_univ_otf
class backprop_graph(object):
    r"""
    Graph used for backward propagation of winning conditions in parity
    games.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, stop_asap=True):
        r"""Construct the backpropagation graph."""
        _impl.backprop_graph_swiginit(self, _impl.new_backprop_graph(stop_asap))
    new_state = _swig_new_instance_method(_impl.backprop_graph_new_state)
    set_name = _swig_new_instance_method(_impl.backprop_graph_set_name)
    new_edge = _swig_new_instance_method(_impl.backprop_graph_new_edge)
    freeze_state = _swig_new_instance_method(_impl.backprop_graph_freeze_state)
    is_frozen = _swig_new_instance_method(_impl.backprop_graph_is_frozen)
    is_determined = _swig_new_instance_method(_impl.backprop_graph_is_determined)
    winner = _swig_new_instance_method(_impl.backprop_graph_winner)
    choice = _swig_new_instance_method(_impl.backprop_graph_choice)
    set_winner = _swig_new_instance_method(_impl.backprop_graph_set_winner)
    print_dot = _swig_new_instance_method(_impl.backprop_graph_print_dot)
    num_edges = _swig_new_instance_method(_impl.backprop_graph_num_edges)
    __swig_destroy__ = _impl.delete_backprop_graph

# Register backprop_graph in _impl:
_impl.backprop_graph_swigregister(backprop_graph)
cleanup_acceptance_here = _impl.cleanup_acceptance_here
cleanup_acceptance = _impl.cleanup_acceptance
simplify_acceptance_here = _impl.simplify_acceptance_here
simplify_acceptance = _impl.simplify_acceptance
reduce_buchi_acceptance_set_here = _impl.reduce_buchi_acceptance_set_here
enlarge_buchi_acceptance_set_here = _impl.enlarge_buchi_acceptance_set_here
class nca_st_info(object):
    r"""
    A vector of nca_st_info is given as argument to nsa_to_nca() or
    dnf_to_nca(). Each nca_st_info has information about a state that must be
    seen infinitely often.
    For a state 's' visited infinitely often by a run, the information
    provided is:
     - the clause number satisfied by the run (from left to right)
     - the state number of 's'
     - destinations of all outgoing edges of 's' (represented as a bitvect)
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    clause_num = property(_impl.nca_st_info_clause_num_get, _impl.nca_st_info_clause_num_set, doc=r"""Index of the NCA clause for this state.""")
    state_num = property(_impl.nca_st_info_state_num_get, _impl.nca_st_info_state_num_set, doc=r"""State number in the NCA.""")
    all_dst = property(_impl.nca_st_info_all_dst_get, _impl.nca_st_info_all_dst_set, doc=r"""Bit vector of all successor states.""")

    def __init__(self, clause, st, dst):
        r"""
        Construct an nca_st_info entry.

        :type clause: int
        :param clause:  clause index
        :type st: int
        :param st:      state number
        :type dst: bitvect
        :param dst:     bitvector of successor states (ownership taken)
        """
        _impl.nca_st_info_swiginit(self, _impl.new_nca_st_info(clause, st, dst))
    __swig_destroy__ = _impl.delete_nca_st_info

# Register nca_st_info in _impl:
_impl.nca_st_info_swigregister(nca_st_info)
nsa_to_nca = _impl.nsa_to_nca
dnf_to_nca = _impl.dnf_to_nca
to_nca = _impl.to_nca
nsa_to_dca = _impl.nsa_to_dca
dnf_to_dca = _impl.dnf_to_dca
to_dca = _impl.to_dca
complete_here = _impl.complete_here
complete = _impl.complete
delay_branching_here = _impl.delay_branching_here
restrict_dead_end_edges_here = _impl.restrict_dead_end_edges_here
analyze_dependent_output = _impl.analyze_dependent_output
degeneralize = _impl.degeneralize
degeneralize_tba = _impl.degeneralize_tba
partial_degeneralize = _impl.partial_degeneralize
is_partially_degeneralizable = _impl.is_partially_degeneralizable
propagate_marks_vector = _impl.propagate_marks_vector
propagate_marks_here = _impl.propagate_marks_here
tgba_determinize = _impl.tgba_determinize
print_dot = _impl.print_dot
dualize = _impl.dualize
class emptiness_check_result(object):
    r"""
    You can create an emptiness check either by instantiating it
    explicitly (calling one of the functions of
    'emptiness_check_algorithms)', or indirectly via
    make_emptiness_check_instantiator().  The latter function
    allows user-options to influence the choice of the
    emptiness-check algorithm used, and the intermediate
    instantiator object can be used to query the properties of the
    emptiness check selected.

    All emptiness-check algorithms follow the same interface.
    Basically once you have constructed an instance of
    emptiness_check, you should call
    emptiness_check::check() to check the automaton.

    If emptiness_check::check() returns 0, then the automaton
    was found empty.  Otherwise the automaton accepts some run.
    (Beware that some algorithms---those using bit-state
    hashing---may find the automaton to be empty even if it is not
    actually empty.)

    When emptiness_check::check() does not return 0, it
    returns an instance of emptiness_check_result.  You can
    try to call emptiness_check_result::accepting_run() to
    obtain an accepting run.  For some emptiness-check algorithms,
    emptiness_check_result::accepting_run() will require some
    extra computation.  Most emptiness-check algorithms are able to
    return such an accepting run, however this is not mandatory and
    emptiness_check_result::accepting_run() can return 0 (this
    does not mean in any way that no accepting run exists).

    The acceptance run returned by
    emptiness_check_result::accepting_run(), if any, is of
    type twa_run.  See 'twa_run' for existing
    operations on these objects.


    The result of an emptiness check.

    Instances of this class should not last longer than the
    instances of emptiness_check that produced them as they
    may reference data internal to the check.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""Construct a result for the given automaton and options."""
        _impl.emptiness_check_result_swiginit(self, _impl.new_emptiness_check_result(*args))
    __swig_destroy__ = _impl.delete_emptiness_check_result
    accepting_run = _swig_new_instance_method(_impl.emptiness_check_result_accepting_run)
    automaton = _swig_new_instance_method(_impl.emptiness_check_result_automaton)
    options = _swig_new_instance_method(_impl.emptiness_check_result_options)
    parse_options = _swig_new_instance_method(_impl.emptiness_check_result_parse_options)
    statistics = _swig_new_instance_method(_impl.emptiness_check_result_statistics)

# Register emptiness_check_result in _impl:
_impl.emptiness_check_result_swigregister(emptiness_check_result)
class emptiness_check(object):
    r"""Common interface to emptiness check algorithms."""

    thisown = 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
    automaton = _swig_new_instance_method(_impl.emptiness_check_automaton)
    options = _swig_new_instance_method(_impl.emptiness_check_options)
    parse_options = _swig_new_instance_method(_impl.emptiness_check_parse_options)
    safe = _swig_new_instance_method(_impl.emptiness_check_safe)
    check = _swig_new_instance_method(_impl.emptiness_check_check)
    statistics = _swig_new_instance_method(_impl.emptiness_check_statistics)
    emptiness_check_statistics = _swig_new_instance_method(_impl.emptiness_check_emptiness_check_statistics)
    print_stats = _swig_new_instance_method(_impl.emptiness_check_print_stats)
    options_updated = _swig_new_instance_method(_impl.emptiness_check_options_updated)

# Register emptiness_check in _impl:
_impl.emptiness_check_swigregister(emptiness_check)
class emptiness_check_instantiator(object):
    r"""Dynamically create emptiness checks.  Given their name and options."""

    thisown = 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
    instantiate = _swig_new_instance_method(_impl.emptiness_check_instantiator_instantiate)
    options = _swig_new_instance_method(_impl.emptiness_check_instantiator_options)
    min_sets = _swig_new_instance_method(_impl.emptiness_check_instantiator_min_sets)
    max_sets = _swig_new_instance_method(_impl.emptiness_check_instantiator_max_sets)
    __swig_destroy__ = _impl.delete_emptiness_check_instantiator

# Register emptiness_check_instantiator in _impl:
_impl.emptiness_check_instantiator_swigregister(emptiness_check_instantiator)
make_emptiness_check_instantiator = _impl.make_emptiness_check_instantiator
class twa_run(object):
    r"""An accepted run, for a twa."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    prefix = property(_impl.twa_run_prefix_get, _impl.twa_run_prefix_set, doc=r"""The prefix part of the run.""")
    cycle = property(_impl.twa_run_cycle_get, _impl.twa_run_cycle_set, doc=r"""The cycle part of the run.""")
    aut = property(_impl.twa_run_aut_get, _impl.twa_run_aut_set, doc=r"""The automaton this run is associated with.""")
    __swig_destroy__ = _impl.delete_twa_run

    def __init__(self, *args):
        r"""
        *Overload 1:*
        Construct an empty run for the given automaton.

        |

        *Overload 2:*
        Copy constructor.
        """
        _impl.twa_run_swiginit(self, _impl.new_twa_run(*args))
    ensure_non_empty_cycle = _swig_new_instance_method(_impl.twa_run_ensure_non_empty_cycle)
    reduce = _swig_new_instance_method(_impl.twa_run_reduce)
    project = _swig_new_instance_method(_impl.twa_run_project)
    replay = _swig_new_instance_method(_impl.twa_run_replay)
    highlight = _swig_new_instance_method(_impl.twa_run_highlight)
    as_twa = _swig_new_instance_method(_impl.twa_run_as_twa)
    __str__ = _swig_new_instance_method(_impl.twa_run___str__)

# Register twa_run in _impl:
_impl.twa_run_swigregister(twa_run)
class step(object):
    r"""
    A single step in a TωA run, pairing a state with an edge label
    and acceptance marks.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    s = property(_impl.step_s_get, _impl.step_s_set, doc=r"""Source state.""")
    label = property(_impl.step_label_get, _impl.step_label_set, doc=r"""Transition label.""")
    acc = property(_impl.step_acc_get, _impl.step_acc_set, doc=r"""Acceptance marks on the transition.""")

    def __init__(self, *args):
        r"""Construct a step from a state, label, and acceptance marks."""
        _impl.step_swiginit(self, _impl.new_step(*args))
    __swig_destroy__ = _impl.delete_step

# Register step in _impl:
_impl.step_swigregister(step)
class list_step(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_impl.list_step_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_impl.list_step___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.list_step___bool__)
    __len__ = _swig_new_instance_method(_impl.list_step___len__)
    __getslice__ = _swig_new_instance_method(_impl.list_step___getslice__)
    __setslice__ = _swig_new_instance_method(_impl.list_step___setslice__)
    __delslice__ = _swig_new_instance_method(_impl.list_step___delslice__)
    __delitem__ = _swig_new_instance_method(_impl.list_step___delitem__)
    __getitem__ = _swig_new_instance_method(_impl.list_step___getitem__)
    __setitem__ = _swig_new_instance_method(_impl.list_step___setitem__)
    pop = _swig_new_instance_method(_impl.list_step_pop)
    append = _swig_new_instance_method(_impl.list_step_append)
    empty = _swig_new_instance_method(_impl.list_step_empty)
    size = _swig_new_instance_method(_impl.list_step_size)
    swap = _swig_new_instance_method(_impl.list_step_swap)
    begin = _swig_new_instance_method(_impl.list_step_begin)
    end = _swig_new_instance_method(_impl.list_step_end)
    rbegin = _swig_new_instance_method(_impl.list_step_rbegin)
    rend = _swig_new_instance_method(_impl.list_step_rend)
    clear = _swig_new_instance_method(_impl.list_step_clear)
    get_allocator = _swig_new_instance_method(_impl.list_step_get_allocator)
    pop_back = _swig_new_instance_method(_impl.list_step_pop_back)
    erase = _swig_new_instance_method(_impl.list_step_erase)

    def __init__(self, *args):
        _impl.list_step_swiginit(self, _impl.new_list_step(*args))
    push_back = _swig_new_instance_method(_impl.list_step_push_back)
    front = _swig_new_instance_method(_impl.list_step_front)
    back = _swig_new_instance_method(_impl.list_step_back)
    assign = _swig_new_instance_method(_impl.list_step_assign)
    resize = _swig_new_instance_method(_impl.list_step_resize)
    insert = _swig_new_instance_method(_impl.list_step_insert)
    pop_front = _swig_new_instance_method(_impl.list_step_pop_front)
    push_front = _swig_new_instance_method(_impl.list_step_push_front)
    reverse = _swig_new_instance_method(_impl.list_step_reverse)
    __swig_destroy__ = _impl.delete_list_step

# Register list_step in _impl:
_impl.list_step_swigregister(list_step)
difference_word_forq = _impl.difference_word_forq
contains_forq = _impl.contains_forq
couvreur99 = _impl.couvreur99
generic_emptiness_check = _impl.generic_emptiness_check
generic_accepting_run = _impl.generic_accepting_run
generic_emptiness_check_for_scc = _impl.generic_emptiness_check_for_scc
generic_emptiness_check_select_version = _impl.generic_emptiness_check_select_version
accepting_transitions_scc = _impl.accepting_transitions_scc
accepting_transitions = _impl.accepting_transitions
update_bounds_given_here = _impl.update_bounds_given_here
update_bounds_given = _impl.update_bounds_given
bounds_simplify_here = _impl.bounds_simplify_here
bounds_simplify = _impl.bounds_simplify
stutterize_given = _impl.stutterize_given
print_lbtt = _impl.print_lbtt
ltl_to_taa = _impl.ltl_to_taa
ltl_to_tgba_fm = _impl.ltl_to_tgba_fm
class fm_edge(object):
    r"""A single successor edge from a formula-state."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    cond = property(_impl.fm_edge_cond_get, _impl.fm_edge_cond_set, doc=r"""Condition on atomic propositions.""")
    dst = property(_impl.fm_edge_dst_get, _impl.fm_edge_dst_set, doc=r"""Destination formula-state.""")
    acc = property(_impl.fm_edge_acc_get, _impl.fm_edge_acc_set, doc=r"""
    Acceptance marks, using negated-Inf semantics;
    see 'acc_semantics' for details.
    """)

    def __init__(self):
        _impl.fm_edge_swiginit(self, _impl.new_fm_edge())
    __swig_destroy__ = _impl.delete_fm_edge

# Register fm_edge in _impl:
_impl.fm_edge_swigregister(fm_edge)
class fm_simple_edge(object):
    r"""
    A simplified successor edge without condition.

    This is a lighter variant of fm_edge that omits the BDD condition
    on atomic propositions.  It is useful for on-the-fly emptiness
    checks where the condition is known to be bddtrue (e.g., after
    realizability simplification has removed all atomic propositions).
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    acc = property(_impl.fm_simple_edge_acc_get, _impl.fm_simple_edge_acc_set, doc=r"""Acceptance marks, using negated-Inf semantics.""")
    dst = property(_impl.fm_simple_edge_dst_get, _impl.fm_simple_edge_dst_set, doc=r"""Destination formula-state.""")

    def __init__(self):
        _impl.fm_simple_edge_swiginit(self, _impl.new_fm_simple_edge())
    __swig_destroy__ = _impl.delete_fm_simple_edge

# Register fm_simple_edge in _impl:
_impl.fm_simple_edge_swigregister(fm_simple_edge)
class ltl_to_tgba_fm_otf(object):
    r"""
    On-the-fly LTL→TGBA explorer.

    Encapsulates the data structures from ltl_to_tgba_fm() so that
    successors of a formula-state can be computed without building
    the full automaton.  Two views are provided:

      - succ_as_bdd(): a symbolic BDD view (cached, no exprop)
      - succ_as_edges(): an explicit edge list (exprop, simplification,
        canonicalization, and branching postponement applied here)

    The class also exposes accessors so that a client can decompose
    the BDD returned by succ_as_bdd() on its own if needed.



    This class does not own a twa_graph; it receives one from the
    caller (*aut)* and uses it only to call register_ap() as new
    atomic propositions are discovered, and to update its acceptance
    condition as new colors are allocated.  The acceptance condition
    of *aut* is therefore mutated during the lifetime of the
    explorer.

    The Couvreur translation internally encodes promises P(…) using
    negated Inf sets: the acceptance condition of *aut* effectively
    represents Inf(!0)&Inf(!1)&…&Inf(!(N-1)), a form Spot does not
    directly support.  The acceptance marks returned in
    fm_edge::acc therefore correspond to this negated semantics.

    Because the number of acceptance sets N grows during exploration
    (each new promise allocates a fresh color), the marks cannot be
    complemented on-the-fly; complementation must wait until
    exploration is complete and the final N is known.  At that point,
    build a proper TGBA by complementing each edge's mark with
    respect to N and setting the acceptance condition to
    generalized-Büchi:

    .. code-block:: c++

          auto& acc = aut->acc();
          for (auto& e: aut->edges())
            e.acc = acc.comp(e.acc);
          acc.set_generalized_buchi();
    This is exactly what ltl_to_tgba_fm() does before returning the
    completed automaton.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Constructor.

        Normalizes the formula, initializes the BDD variable mappings,
        and prepares all internal data structures.

        :type f: :py:class:`formula`
        :param f:          the LTL/PSL formula
        :type aut: :py:class:`twa_graph`
        :param aut:        the automaton being built, used only to call
                              register_ap(); the explorer never adds states
                              or edges itself
        :type opts: spot::ltl_to_tgba_fm_otf::options, optional
        :param opts:       translation options
        :type simplifier: :py:class:`tl_simplifier`, optional
        :param simplifier: optional LTL simplifier (owned by caller)
        :type unobs: :py:class:`atomic_prop_set`, optional
        :param unobs:      optional set of unobservable events
        """
        _impl.ltl_to_tgba_fm_otf_swiginit(self, _impl.new_ltl_to_tgba_fm_otf(*args))
    __swig_destroy__ = _impl.delete_ltl_to_tgba_fm_otf
    init_state = _swig_new_instance_method(_impl.ltl_to_tgba_fm_otf_init_state)
    orig_formula = _swig_new_instance_method(_impl.ltl_to_tgba_fm_otf_orig_formula)
    succ_as_bdd = _swig_new_instance_method(_impl.ltl_to_tgba_fm_otf_succ_as_bdd)
    succ_as_edges = _swig_new_instance_method(_impl.ltl_to_tgba_fm_otf_succ_as_edges)
    succ_as_acc_and_dest = _swig_new_instance_method(_impl.ltl_to_tgba_fm_otf_succ_as_acc_and_dest)
    var_set = _swig_new_instance_method(_impl.ltl_to_tgba_fm_otf_var_set)
    next_set = _swig_new_instance_method(_impl.ltl_to_tgba_fm_otf_next_set)
    a_set = _swig_new_instance_method(_impl.ltl_to_tgba_fm_otf_a_set)
    conj_bdd_to_formula = _swig_new_instance_method(_impl.ltl_to_tgba_fm_otf_conj_bdd_to_formula)
    bdd_to_mark = _swig_new_instance_method(_impl.ltl_to_tgba_fm_otf_bdd_to_mark)
    register_next_variable = _swig_new_instance_method(_impl.ltl_to_tgba_fm_otf_register_next_variable)
    get_dict = _swig_new_instance_method(_impl.ltl_to_tgba_fm_otf_get_dict)

# Register ltl_to_tgba_fm_otf in _impl:
_impl.ltl_to_tgba_fm_otf_swigregister(ltl_to_tgba_fm_otf)
class mtdfa_stats(object):
    r"""
    MTDFAs are a representation of transition-based finite
    deterministic automata labeled by Boolean formulas.  Each state
    is represented by a BDD encoding the Boolean formulas labeling
    the successor transition.  The leaves of these BDDs are not only
    the usual `bddfalse` and `bddtrue`, but some integer-valued
    terminal representing the destination state.  A terminal with
    integer label $2d+b$ represents destination state $d$ and uses
    b∈{0,1} to indicate whether the transition is accepting
    (i.e., the evaluation can stop after reading the last letter).
    The `bddfalse` and `bddtrue` nodes are kept to represent
    rejecting and accepting sinks; using them helps some to shortcut
    some BDD operations.

    'duret.25.ciaa'

    statistics about an mtdfa instance

    This holds the result of a call to mtdfa::get_stats().
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    states = property(_impl.mtdfa_stats_states_get, _impl.mtdfa_stats_states_set, doc=r"""
    number of roots

    This excludes true and false, that are never
    listed as roots.
    """)
    aps = property(_impl.mtdfa_stats_aps_get, _impl.mtdfa_stats_aps_set, doc=r"""
    number of atomic propositions

    This is the number of atomic propositions used in the original
    formula.  The propositions actually used in the automaton may be
    fewer.
    """)
    nodes = property(_impl.mtdfa_stats_nodes_get, _impl.mtdfa_stats_nodes_set, doc=r"""
    Number of internal nodes (or decision nodes)

    Only filled if mtdfa::get_stats() was passed the `nodes` option.
    """)
    terminals = property(_impl.mtdfa_stats_terminals_get, _impl.mtdfa_stats_terminals_set, doc=r"""
    Number of terminal nodes.

    This excludes the true and false, constant nodes.

    Only filled if mtdfa::get_stats() was passed the `nodes` option.
    """)
    has_true = property(_impl.mtdfa_stats_has_true_get, _impl.mtdfa_stats_has_true_set, doc=r"""
    Whether the true and false constants are used.

    Only filled if mtdfa::get_stats() was passed the `nodes` option.
    """)
    has_false = property(_impl.mtdfa_stats_has_false_get, _impl.mtdfa_stats_has_false_set)
    paths = property(_impl.mtdfa_stats_paths_get, _impl.mtdfa_stats_paths_set, doc=r"""
    Number of paths between a root and a leaf (terminal
    or constant)

    Only filled if mtdfa::get_stats() was passed the `edges` option.
    """)
    edges = property(_impl.mtdfa_stats_edges_get, _impl.mtdfa_stats_edges_set, doc=r"""
    Number of pairs (root, leaf) for which a path exists.

    Only filled if mtdfa::get_stats() was passed the `edges` option.
    """)

    def __init__(self):
        _impl.mtdfa_stats_swiginit(self, _impl.new_mtdfa_stats())
    __swig_destroy__ = _impl.delete_mtdfa_stats

# Register mtdfa_stats in _impl:
_impl.mtdfa_stats_swigregister(mtdfa_stats)
class mtdfa(object):
    r"""
    A DFA represented using shared multi-terminal BDDs

    Such a DFA is represented by a vector of BDDs: one BDD per state.
    Each BDD encodes the set of outgoing transitions of a state.  The
    of the transitions encoded naturally using BDD decision variables,
    and the destination state is stored as a "terminal" node.

    Those DFA use transition-based acceptance, and that acceptance
    is represented by the last bit of the value stored in the
    terminal.

    If a transition should reach state V, the terminal stores the
    value 2*V if the transition is rejecting, or 2*V+1 if the
    transition is accepting.

    `bddfalse` and `bddtrue` terminals are used to represent
    rejecting and accepting sink states.

    'duret.25.ciaa'
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, dict):
        r"""
        Create an empty mtdfa

        The *dict* is used to record how BDD variables map to atomic
        propositions.
        """
        _impl.mtdfa_swiginit(self, _impl.new_mtdfa(dict))
    __swig_destroy__ = _impl.delete_mtdfa
    states = property(_impl.mtdfa_states_get, _impl.mtdfa_states_set, doc=r"""BDD transitions for each root state.""")
    names = property(_impl.mtdfa_names_get, _impl.mtdfa_names_set, doc=r"""Name formula for each root state.""")
    aps = property(_impl.mtdfa_aps_get, _impl.mtdfa_aps_set, doc=r"""
    The list of atomic propositions possibly used by the automaton.

    This is actually the list of atomic propositions that appeared
    in the formulas/automata that were used to build this
    automaton.  The automaton itself may use fewer atomic
    propositions, for instance in case some of them cancel each other.

    This vector is sorted by formula ID, to make it easy to merge
    with another sorted vector.
    """)
    num_roots = _swig_new_instance_method(_impl.mtdfa_num_roots)
    num_states = _swig_new_instance_method(_impl.mtdfa_num_states)
    is_empty = _swig_new_instance_method(_impl.mtdfa_is_empty)
    print_dot = _swig_new_instance_method(_impl.mtdfa_print_dot)
    as_twa = _swig_new_instance_method(_impl.mtdfa_as_twa)
    get_stats = _swig_new_instance_method(_impl.mtdfa_get_stats)
    get_dict = _swig_new_instance_method(_impl.mtdfa_get_dict)
    set_controllable_variables = _swig_new_instance_method(_impl.mtdfa_set_controllable_variables)
    get_controllable_variables = _swig_new_instance_method(_impl.mtdfa_get_controllable_variables)

# Register mtdfa in _impl:
_impl.mtdfa_swigregister(mtdfa)
ltlf_to_mtdfa = _impl.ltlf_to_mtdfa
state_refine = _impl.state_refine
r"""no backpropagation, just local refinement"""
bfs_node_backprop = _impl.bfs_node_backprop
r"""on-the-fly, BFS"""
dfs_node_backprop = _impl.dfs_node_backprop
r"""on-the-fly, DFS"""
class ltlf_synthesis_options(object):
    r"""
    Fine-tuning options for LTLf synthesis

    These options can be passed to ltlf_to_mtdfa_for_synthesis() to
    control the optimizations performed during the construction.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    one_step_preprocess = property(_impl.ltlf_synthesis_options_one_step_preprocess_get, _impl.ltlf_synthesis_options_one_step_preprocess_set, doc=r"""
    Perform one-step preprocessing.

    When enabled, the formula for each step is first simplified in
    an attempt to prove realizability or unrealizability in one step.
    """)
    terminating_semantics = property(_impl.ltlf_synthesis_options_terminating_semantics_get, _impl.ltlf_synthesis_options_terminating_semantics_set, doc=r"""
    Use terminating semantics when building a controller

    Build a controller that knows when to stop.  This
    disables some minor optimizations of the game.

    This option is ignored when checking for realizability.
    """)
    fuse_same_bdds = property(_impl.ltlf_synthesis_options_fuse_same_bdds_get, _impl.ltlf_synthesis_options_fuse_same_bdds_set, doc=r"""Merge states with identical MTBDD representation.""")
    simplify_terms = property(_impl.ltlf_synthesis_options_simplify_terms_get, _impl.ltlf_synthesis_options_simplify_terms_set, doc=r"""Simplify formulas generated for states using cheap rewritings.""")
    detect_empty_univ = property(_impl.ltlf_synthesis_options_detect_empty_univ_get, _impl.ltlf_synthesis_options_detect_empty_univ_set, doc=r"""
    Detect empty or universal languages after construction.

    If, after construction of the whole automaton, it was found
    that all states were rejecting, or all states were accepting,
    the automaton is reduced to a rejecting or accepting sink state.
    """)

    def __init__(self):
        _impl.ltlf_synthesis_options_swiginit(self, _impl.new_ltlf_synthesis_options())
    __swig_destroy__ = _impl.delete_ltlf_synthesis_options

# Register ltlf_synthesis_options in _impl:
_impl.ltlf_synthesis_options_swigregister(ltlf_synthesis_options)
ltlf_to_mtdfa_for_synthesis = _impl.ltlf_to_mtdfa_for_synthesis
ltlf_to_mtdfa_compose = _impl.ltlf_to_mtdfa_compose
minimize_mtdfa = _impl.minimize_mtdfa
twadfa_to_mtdfa = _impl.twadfa_to_mtdfa
class ltlf_translator(object):
    r"""
    "Semi-internal" class used to implement ltlf_to_mtdfa()

    It is public only to make it possible to demonstrate the inner
    working of the translation.  Do not rely on the interface to be
    stable.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, dict, simplify_terms=True):
        r"""Construct the translator with the given BDD dictionary."""
        _impl.ltlf_translator_swiginit(self, _impl.new_ltlf_translator(dict, simplify_terms))
    ltlf_to_mtdfa = _swig_new_instance_method(_impl.ltlf_translator_ltlf_to_mtdfa)
    ltlf_to_mtdfa_synthesis = _swig_new_instance_method(_impl.ltlf_translator_ltlf_to_mtdfa_synthesis)
    ltlf_to_mtbdd = _swig_new_instance_method(_impl.ltlf_translator_ltlf_to_mtbdd)
    leaf_to_formula = _swig_new_instance_method(_impl.ltlf_translator_leaf_to_formula)
    terminal_to_formula = _swig_new_instance_method(_impl.ltlf_translator_terminal_to_formula)
    formula_to_int = _swig_new_instance_method(_impl.ltlf_translator_formula_to_int)
    formula_to_terminal = _swig_new_instance_method(_impl.ltlf_translator_formula_to_terminal)
    formula_to_terminal_bdd = _swig_new_instance_method(_impl.ltlf_translator_formula_to_terminal_bdd)
    formula_to_terminal_bdd_as_int = _swig_new_instance_method(_impl.ltlf_translator_formula_to_terminal_bdd_as_int)
    combine_and = _swig_new_instance_method(_impl.ltlf_translator_combine_and)
    combine_or = _swig_new_instance_method(_impl.ltlf_translator_combine_or)
    combine_implies = _swig_new_instance_method(_impl.ltlf_translator_combine_implies)
    combine_equiv = _swig_new_instance_method(_impl.ltlf_translator_combine_equiv)
    combine_xor = _swig_new_instance_method(_impl.ltlf_translator_combine_xor)
    combine_not = _swig_new_instance_method(_impl.ltlf_translator_combine_not)
    propeq_encode = _swig_new_instance_method(_impl.ltlf_translator_propeq_encode)
    propeq_representative = _swig_new_instance_method(_impl.ltlf_translator_propeq_representative)
    formula_propeq_to_int = _swig_new_instance_method(_impl.ltlf_translator_formula_propeq_to_int)
    formula_propeq_to_terminal_bdd_as_int = _swig_new_instance_method(_impl.ltlf_translator_formula_propeq_to_terminal_bdd_as_int)
    formula_propeq_to_terminal = _swig_new_instance_method(_impl.ltlf_translator_formula_propeq_to_terminal)
    get_cache = _swig_new_instance_method(_impl.ltlf_translator_get_cache)
    __swig_destroy__ = _impl.delete_ltlf_translator

# Register ltlf_translator in _impl:
_impl.ltlf_translator_swigregister(ltlf_translator)
mtdfa_winning_region = _impl.mtdfa_winning_region
mtdfa_winning_region_lazy = _impl.mtdfa_winning_region_lazy
mtdfa_winning_region_lazy3 = _impl.mtdfa_winning_region_lazy3
mtdfa_restrict_as_game = _impl.mtdfa_restrict_as_game
mtdfa_to_backprop = _impl.mtdfa_to_backprop
mtdfa_winning_strategy = _impl.mtdfa_winning_strategy
mtdfa_strategy_to_mealy = _impl.mtdfa_strategy_to_mealy
g_f_terminal_inplace = _impl.g_f_terminal_inplace
gf_guarantee_to_ba_maybe = _impl.gf_guarantee_to_ba_maybe
gf_guarantee_to_ba = _impl.gf_guarantee_to_ba
fg_safety_to_dca_maybe = _impl.fg_safety_to_dca_maybe
fg_safety_to_dca = _impl.fg_safety_to_dca
compsusp = _impl.compsusp
contains = _impl.contains
are_equivalent = _impl.are_equivalent
containment_select_version = _impl.containment_select_version
language_map = _impl.language_map
highlight_languages = _impl.highlight_languages
explicit_magic_search = _impl.explicit_magic_search
bit_state_hashing_magic_search = _impl.bit_state_hashing_magic_search
magic_search = _impl.magic_search
match_states = _impl.match_states
match_states_decorate = _impl.match_states_decorate
MCS_TIE_ANY = _impl.MCS_TIE_ANY
r"""Break ties by picking the first possible state."""
MCS_TIE_SCC = _impl.MCS_TIE_SCC
r"""
    Break ties by picking states from the "highest" SCCs

    This is based on the topological ordering of SCCs computed
    by scc_info.  The initial state is always in the highest
    SCC, and the smallest SCC has no exit.
    """
maximum_cardinality_search = _impl.maximum_cardinality_search
maximum_cardinality_search_reorder_here = _impl.maximum_cardinality_search_reorder_here
minimize_monitor = _impl.minimize_monitor
minimize_wdba = _impl.minimize_wdba
minimize_obligation = _impl.minimize_obligation
minimize_obligation_guaranteed_to_work = _impl.minimize_obligation_guaranteed_to_work
is_mealy = _impl.is_mealy
is_separated_mealy = _impl.is_separated_mealy
is_split_mealy = _impl.is_split_mealy
is_input_deterministic_mealy = _impl.is_input_deterministic_mealy
split_separated_mealy = _impl.split_separated_mealy
split_separated_mealy_here = _impl.split_separated_mealy_here
unsplit_mealy = _impl.unsplit_mealy
reduce_mealy = _impl.reduce_mealy
reduce_mealy_here = _impl.reduce_mealy_here
minimize_mealy = _impl.minimize_mealy
is_split_mealy_specialization = _impl.is_split_mealy_specialization
mealy_product = _impl.mealy_product
simplify_mealy_here = _impl.simplify_mealy_here
terminating_mealy_to_buchi = _impl.terminating_mealy_to_buchi
print_never_claim = _impl.print_never_claim
randomize = _impl.randomize
rabin_is_buchi_realizable = _impl.rabin_is_buchi_realizable
rabin_to_buchi_if_realizable = _impl.rabin_to_buchi_if_realizable
rabin_to_buchi_maybe = _impl.rabin_to_buchi_maybe
remove_fin = _impl.remove_fin
class remove_ap(object):
    r"""Helper for stripping or fixing atomic propositions in automata."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    add_ap = _swig_new_instance_method(_impl.remove_ap_add_ap)
    empty = _swig_new_instance_method(_impl.remove_ap_empty)
    strip = _swig_new_instance_method(_impl.remove_ap_strip)

    def __init__(self):
        _impl.remove_ap_swiginit(self, _impl.new_remove_ap())
    __swig_destroy__ = _impl.delete_remove_ap

# Register remove_ap in _impl:
_impl.remove_ap_swigregister(remove_ap)
to_finite = _impl.to_finite
to_generalized_buchi = _impl.to_generalized_buchi
streett_to_generalized_buchi = _impl.streett_to_generalized_buchi
streett_to_generalized_buchi_maybe = _impl.streett_to_generalized_buchi_maybe
to_generalized_rabin = _impl.to_generalized_rabin
to_generalized_streett = _impl.to_generalized_streett
dnf_to_streett = _impl.dnf_to_streett
sbacc = _impl.sbacc
edge_filter_choice_keep = _impl.edge_filter_choice_keep
edge_filter_choice_ignore = _impl.edge_filter_choice_ignore
edge_filter_choice_cut = _impl.edge_filter_choice_cut
class keep_all(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

# Register keep_all in _impl:
_impl.keep_all_swigregister(keep_all)
class keep_inner_scc(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, sccof, desired_scc):
        _impl.keep_inner_scc_swiginit(self, _impl.new_keep_inner_scc(sccof, desired_scc))
    __swig_destroy__ = _impl.delete_keep_inner_scc

# Register keep_inner_scc in _impl:
_impl.keep_inner_scc_swigregister(keep_inner_scc)
class scc_info_node(object):
    r"""Storage for SCC related information."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        *Overload 1:*
        Default-construct an empty trivial SCC node.

        |

        *Overload 2:*
        Construct an SCC node with given acceptance information.
        """
        _impl.scc_info_node_swiginit(self, _impl.new_scc_info_node(*args))
    is_trivial = _swig_new_instance_method(_impl.scc_info_node_is_trivial)
    is_accepting = _swig_new_instance_method(_impl.scc_info_node_is_accepting)
    is_rejecting = _swig_new_instance_method(_impl.scc_info_node_is_rejecting)
    is_useful = _swig_new_instance_method(_impl.scc_info_node_is_useful)
    acc_marks = _swig_new_instance_method(_impl.scc_info_node_acc_marks)
    common_marks = _swig_new_instance_method(_impl.scc_info_node_common_marks)
    states = _swig_new_instance_method(_impl.scc_info_node_states)
    one_state = _swig_new_instance_method(_impl.scc_info_node_one_state)
    succ = _swig_new_instance_method(_impl.scc_info_node_succ)
    __swig_destroy__ = _impl.delete_scc_info_node

# Register scc_info_node in _impl:
_impl.scc_info_node_swigregister(scc_info_node)
scc_info_options_NONE = _impl.scc_info_options_NONE
r"""
    Explore all SCCs, but do not track the states of each SCC and
    the successor SCC of each SCC.  This is enough to call the
    scc_of() method.
    """
scc_info_options_STOP_ON_ACC = _impl.scc_info_options_STOP_ON_ACC
r"""
    Stop exploring after an accepting SCC has been found.
    Using this option forbids future uses of is_useful_scc() and
    is_useful_state().  Using it will also cause the output of
    succ() to be incomplete.
    """
scc_info_options_TRACK_STATES = _impl.scc_info_options_TRACK_STATES
r"""
    Keep a vector of all states belonging to each SCC.  Using this
    option is a precondition for using states_of(), edges_of(),
    inner_edges_of(), states_on_acc_cycle_of(), and
    determine_unknown_acceptance().
    """
scc_info_options_TRACK_SUCCS = _impl.scc_info_options_TRACK_SUCCS
r"""
    Keep a list of successors of each SCCs.
    Using this option is a precondition for using succ(),
    is_useful_scc(), and is_useful_state().
    """
scc_info_options_TRACK_STATES_IF_FIN_USED = _impl.scc_info_options_TRACK_STATES_IF_FIN_USED
r"""
    Conditionally track states if the acceptance condition uses Fin.
    This is sufficient for determine_unknown_acceptance().
    """
scc_info_options_PROCESS_UNREACHABLE_STATES = _impl.scc_info_options_PROCESS_UNREACHABLE_STATES
r"""
    Also compute SCCs for the unreachable states.  When this is
    used, SCCs are first enumerated from state 0, and then from
    the next unvisited states.  In other words the initial state
    does not play any role.  If STOP_ON_ACC is used with
    PROCESS_UNREACHABLE_STATES, the enumeration will stop as soon
    as an SCC is found, but that SCC might not be reachable.
    """
scc_info_options_ALL = _impl.scc_info_options_ALL
r"""Default behavior: explore everything and track states and succs."""
__and__ = _impl.__and__
__or__ = _impl.__or__
class scc_info(object):
    r"""
    Compute an SCC map and gather assorted information.

    This takes twa_graph as input and compute its SCCs.  This
    class maps all input states to their SCCs, and vice versa.
    It allows iterating over all SCCs of the automaton, and checks
    their acceptance or non-acceptance.

    SCC are numbered in reverse topological order, i.e. the SCC of the
    initial state has the highest number, and if s1 is reachable from
    s2, then s1 < s2. Many algorithms depend on this property to
    determine in what order to iterate the SCCs.

    Additionally this class can be used on alternating automata, but
    in this case, universal transitions are handled like existential
    transitions.  It still makes sense to check which states belong
    to the same SCC, but the acceptance information computed by
    this class is meaningless.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

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

# Register scc_info in _impl:
_impl.scc_info_swigregister(scc_info)

def scc_info_with_options(*args):
    r"""
    Create an scc_info map from some filter.

    This is usually used to prevent some edges from being
    considered as part of cycles, and can additionally restrict
    to exploration to some SCC discovered by another SCC.
    """
    val = _impl.new_scc_info_with_options(*args)
    return val

class scc_and_mark_filter(object):
    r"""
    Create a filter for SCC and marks.

    An scc_and_mark_filter can be passed to scc_info to explore only
    a specific SCC of the original automaton, and to prevent some
    acceptance sets from being considered as part of SCCs.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        *Overload 1:*
        Specify how to restrict scc_info to some SCC and acceptance sets

        :type lower_si: :py:class:`scc_info`
        :param lower_si: the original scc_info that specifies the SCC
        :type lower_scc: int
        :param lower_scc: the SCC number in lower_si
        :type cut_sets: :py:class:`mark_t`
        :param cut_sets: the acceptance sets that should not be part of SCCs.

        |

        *Overload 2:*
        Construct with an additional bitvect of edges to keep.

        |

        *Overload 3:*
        Specify how to restrict scc_info to some acceptance sets

        :type aut: :py:class:`twa_graph`
        :param aut: the automaton to filter
        :type cut_sets: :py:class:`mark_t`
        :param cut_sets: the acceptance sets that should not be part of SCCs.
        """
        _impl.scc_and_mark_filter_swiginit(self, _impl.new_scc_and_mark_filter(*args))
    __swig_destroy__ = _impl.delete_scc_and_mark_filter
    override_acceptance = _swig_new_instance_method(_impl.scc_and_mark_filter_override_acceptance)
    restore_acceptance = _swig_new_instance_method(_impl.scc_and_mark_filter_restore_acceptance)
    get_aut = _swig_new_instance_method(_impl.scc_and_mark_filter_get_aut)
    start_state = _swig_new_instance_method(_impl.scc_and_mark_filter_start_state)
    get_filter = _swig_new_instance_method(_impl.scc_and_mark_filter_get_filter)

# Register scc_and_mark_filter in _impl:
_impl.scc_and_mark_filter_swigregister(scc_and_mark_filter)
dump_scc_info_dot = _impl.dump_scc_info_dot
class scc_info_scc_edges(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, begin, end, tv, sv, dv, filt, efilter, efilter_data):
        _impl.scc_info_scc_edges_swiginit(self, _impl.new_scc_info_scc_edges(begin, end, tv, sv, dv, filt, efilter, efilter_data))
    begin = _swig_new_instance_method(_impl.scc_info_scc_edges_begin)
    end = _swig_new_instance_method(_impl.scc_info_scc_edges_end)
    __iter__ = _swig_new_instance_method(_impl.scc_info_scc_edges___iter__)
    __swig_destroy__ = _impl.delete_scc_info_scc_edges

# Register scc_info_scc_edges in _impl:
_impl.scc_info_scc_edges_swigregister(scc_info_scc_edges)
class scc_info_inner_scc_edges(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, begin, end, tv, sv, dv, filt, efilter, efilter_data):
        _impl.scc_info_inner_scc_edges_swiginit(self, _impl.new_scc_info_inner_scc_edges(begin, end, tv, sv, dv, filt, efilter, efilter_data))
    begin = _swig_new_instance_method(_impl.scc_info_inner_scc_edges_begin)
    end = _swig_new_instance_method(_impl.scc_info_inner_scc_edges_end)
    __iter__ = _swig_new_instance_method(_impl.scc_info_inner_scc_edges___iter__)
    __swig_destroy__ = _impl.delete_scc_info_inner_scc_edges

# Register scc_info_inner_scc_edges in _impl:
_impl.scc_info_inner_scc_edges_swigregister(scc_info_inner_scc_edges)
class vector_twa_graph(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_impl.vector_twa_graph_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_impl.vector_twa_graph___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.vector_twa_graph___bool__)
    __len__ = _swig_new_instance_method(_impl.vector_twa_graph___len__)
    __getslice__ = _swig_new_instance_method(_impl.vector_twa_graph___getslice__)
    __setslice__ = _swig_new_instance_method(_impl.vector_twa_graph___setslice__)
    __delslice__ = _swig_new_instance_method(_impl.vector_twa_graph___delslice__)
    __delitem__ = _swig_new_instance_method(_impl.vector_twa_graph___delitem__)
    __getitem__ = _swig_new_instance_method(_impl.vector_twa_graph___getitem__)
    __setitem__ = _swig_new_instance_method(_impl.vector_twa_graph___setitem__)
    pop = _swig_new_instance_method(_impl.vector_twa_graph_pop)
    append = _swig_new_instance_method(_impl.vector_twa_graph_append)
    empty = _swig_new_instance_method(_impl.vector_twa_graph_empty)
    size = _swig_new_instance_method(_impl.vector_twa_graph_size)
    swap = _swig_new_instance_method(_impl.vector_twa_graph_swap)
    begin = _swig_new_instance_method(_impl.vector_twa_graph_begin)
    end = _swig_new_instance_method(_impl.vector_twa_graph_end)
    rbegin = _swig_new_instance_method(_impl.vector_twa_graph_rbegin)
    rend = _swig_new_instance_method(_impl.vector_twa_graph_rend)
    clear = _swig_new_instance_method(_impl.vector_twa_graph_clear)
    get_allocator = _swig_new_instance_method(_impl.vector_twa_graph_get_allocator)
    pop_back = _swig_new_instance_method(_impl.vector_twa_graph_pop_back)
    erase = _swig_new_instance_method(_impl.vector_twa_graph_erase)

    def __init__(self, *args):
        _impl.vector_twa_graph_swiginit(self, _impl.new_vector_twa_graph(*args))
    push_back = _swig_new_instance_method(_impl.vector_twa_graph_push_back)
    front = _swig_new_instance_method(_impl.vector_twa_graph_front)
    back = _swig_new_instance_method(_impl.vector_twa_graph_back)
    assign = _swig_new_instance_method(_impl.vector_twa_graph_assign)
    resize = _swig_new_instance_method(_impl.vector_twa_graph_resize)
    insert = _swig_new_instance_method(_impl.vector_twa_graph_insert)
    reserve = _swig_new_instance_method(_impl.vector_twa_graph_reserve)
    capacity = _swig_new_instance_method(_impl.vector_twa_graph_capacity)
    __swig_destroy__ = _impl.delete_vector_twa_graph

# Register vector_twa_graph in _impl:
_impl.vector_twa_graph_swigregister(vector_twa_graph)
is_terminal_automaton = _impl.is_terminal_automaton
is_weak_automaton = _impl.is_weak_automaton
is_very_weak_automaton = _impl.is_very_weak_automaton
is_inherently_weak_automaton = _impl.is_inherently_weak_automaton
is_safety_automaton = _impl.is_safety_automaton
is_liveness_automaton = _impl.is_liveness_automaton
check_strength = _impl.check_strength
decompose_scc = _impl.decompose_scc
scc_filter = _impl.scc_filter
scc_filter_states = _impl.scc_filter_states
scc_filter_susp = _impl.scc_filter_susp
class twa_statistics(object):
    r"""Basic statistics (states and edges counts) for a TωA."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    edges = property(_impl.twa_statistics_edges_get, _impl.twa_statistics_edges_set, doc=r"""Number of edges in the automaton.""")
    states = property(_impl.twa_statistics_states_get, _impl.twa_statistics_states_set, doc=r"""Number of states in the automaton.""")

    def __init__(self):
        _impl.twa_statistics_swiginit(self, _impl.new_twa_statistics())
    dump = _swig_new_instance_method(_impl.twa_statistics_dump)
    __swig_destroy__ = _impl.delete_twa_statistics

# Register twa_statistics in _impl:
_impl.twa_statistics_swigregister(twa_statistics)
class twa_sub_statistics(twa_statistics):
    r"""Extended statistics including transition counts for a TωA."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    transitions = property(_impl.twa_sub_statistics_transitions_get, _impl.twa_sub_statistics_transitions_set, doc=r"""Number of transitions in the automaton.""")

    def __init__(self):
        _impl.twa_sub_statistics_swiginit(self, _impl.new_twa_sub_statistics())
    dump = _swig_new_instance_method(_impl.twa_sub_statistics_dump)
    __swig_destroy__ = _impl.delete_twa_sub_statistics

# Register twa_sub_statistics in _impl:
_impl.twa_sub_statistics_swigregister(twa_sub_statistics)
stats_reachable = _impl.stats_reachable
sub_stats_reachable = _impl.sub_stats_reachable
count_all_transitions = _impl.count_all_transitions
class printable_formula(object):
    r"""A printable wrapper for a formula, for use in format strings."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    _print = _swig_new_instance_method(_impl.printable_formula__print)

    def __init__(self):
        _impl.printable_formula_swiginit(self, _impl.new_printable_formula())
    __swig_destroy__ = _impl.delete_printable_formula

# Register printable_formula in _impl:
_impl.printable_formula_swigregister(printable_formula)
class printable_acc_cond(object):
    r"""
    A printable wrapper for an acceptance condition, for use in format
    strings.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    _print = _swig_new_instance_method(_impl.printable_acc_cond__print)

    def __init__(self):
        _impl.printable_acc_cond_swiginit(self, _impl.new_printable_acc_cond())
    __swig_destroy__ = _impl.delete_printable_acc_cond

# Register printable_acc_cond in _impl:
_impl.printable_acc_cond_swigregister(printable_acc_cond)
class printable_scc_info(object):
    r"""
    A printable wrapper for SCC information of an automaton, for use in
    format strings.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    automaton = _swig_new_instance_method(_impl.printable_scc_info_automaton)
    reset = _swig_new_instance_method(_impl.printable_scc_info_reset)
    _print = _swig_new_instance_method(_impl.printable_scc_info__print)

    def __init__(self):
        _impl.printable_scc_info_swiginit(self, _impl.new_printable_scc_info())
    __swig_destroy__ = _impl.delete_printable_scc_info

# Register printable_scc_info in _impl:
_impl.printable_scc_info_swigregister(printable_scc_info)
class printable_size(object):
    r"""
    A printable wrapper reporting reachable and total state/edge
    counts.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    set = _swig_new_instance_method(_impl.printable_size_set)
    _print = _swig_new_instance_method(_impl.printable_size__print)

    def __init__(self):
        _impl.printable_size_swiginit(self, _impl.new_printable_size())
    __swig_destroy__ = _impl.delete_printable_size

# Register printable_size in _impl:
_impl.printable_size_swigregister(printable_size)
class printable_long_size(object):
    r"""
    A printable wrapper reporting reachable and total transition counts
    as long long.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    set = _swig_new_instance_method(_impl.printable_long_size_set)
    _print = _swig_new_instance_method(_impl.printable_long_size__print)

    def __init__(self):
        _impl.printable_long_size_swiginit(self, _impl.new_printable_long_size())
    __swig_destroy__ = _impl.delete_printable_long_size

# Register printable_long_size in _impl:
_impl.printable_long_size_swigregister(printable_long_size)
class stat_printer(object):
    r"""
    prints various statistics about a TGBA

    This object can be configured to display various statistics
    about a TGBA.  Some %-sequence of characters are interpreted in
    the format string, and replaced by the corresponding statistics.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, os, format):
        r"""Construct with an output stream and a format string."""
        _impl.stat_printer_swiginit(self, _impl.new_stat_printer(os, format))
    _print = _swig_new_instance_method(_impl.stat_printer__print)
    __swig_destroy__ = _impl.delete_stat_printer

# Register stat_printer in _impl:
_impl.stat_printer_swigregister(stat_printer)
count_nondet_states = _impl.count_nondet_states
is_universal = _impl.is_universal
is_deterministic = _impl.is_deterministic
highlight_nondet_states = _impl.highlight_nondet_states
highlight_nondet_edges = _impl.highlight_nondet_edges
highlight_semidet_sccs = _impl.highlight_semidet_sccs
is_complete = _impl.is_complete
is_semi_deterministic = _impl.is_semi_deterministic
semidet_sccs = _impl.semidet_sccs
check_determinism = _impl.check_determinism
count_univbranch_states = _impl.count_univbranch_states
count_univbranch_edges = _impl.count_univbranch_edges
is_colored = _impl.is_colored
is_unambiguous = _impl.is_unambiguous
check_unambiguous = _impl.check_unambiguous
scc_has_rejecting_cycle = _impl.scc_has_rejecting_cycle
is_inherently_weak_scc = _impl.is_inherently_weak_scc
is_weak_scc = _impl.is_weak_scc
is_complete_scc = _impl.is_complete_scc
is_terminal_scc = _impl.is_terminal_scc
alternate_players = _impl.alternate_players
solve_parity_game = _impl.solve_parity_game
solve_safety_game = _impl.solve_safety_game
print_pg = _impl.print_pg
pg_print = _impl.pg_print
highlight_strategy = _impl.highlight_strategy
set_state_players = _impl.set_state_players
set_state_player = _impl.set_state_player
get_state_player = _impl.get_state_player
get_state_players = _impl.get_state_players
get_strategy = _impl.get_strategy
set_strategy = _impl.set_strategy
set_synthesis_outputs = _impl.set_synthesis_outputs
get_synthesis_outputs = _impl.get_synthesis_outputs
get_synthesis_output_aps = _impl.get_synthesis_output_aps
set_state_winners = _impl.set_state_winners
set_state_winner = _impl.set_state_winner
get_state_winner = _impl.get_state_winner
get_state_winners = _impl.get_state_winners
simulation = _impl.simulation
simulation_sba = _impl.simulation_sba
cosimulation = _impl.cosimulation
cosimulation_sba = _impl.cosimulation_sba
iterated_simulations = _impl.iterated_simulations
iterated_simulations_sba = _impl.iterated_simulations_sba
reduce_direct_sim = _impl.reduce_direct_sim
reduce_direct_sim_sba = _impl.reduce_direct_sim_sba
reduce_direct_cosim = _impl.reduce_direct_cosim
reduce_direct_cosim_sba = _impl.reduce_direct_cosim_sba
reduce_iterated = _impl.reduce_iterated
reduce_iterated_sba = _impl.reduce_iterated_sba
parity_kind_max = _impl.parity_kind_max
r"""The new acceptance will be a parity max"""
parity_kind_min = _impl.parity_kind_min
r"""The new acceptance will be a parity min"""
parity_kind_same = _impl.parity_kind_same
r"""The new acceptance will keep the kind"""
parity_kind_any = _impl.parity_kind_any
r"""The new acceptance may change the kind"""
parity_style_odd = _impl.parity_style_odd
r"""The new acceptance will be a parity odd"""
parity_style_even = _impl.parity_style_even
r"""The new acceptance will be a parity even"""
parity_style_same = _impl.parity_style_same
r"""The new acceptance will keep the style"""
parity_style_any = _impl.parity_style_any
r"""The new acceptance may change the style"""
change_parity = _impl.change_parity
change_parity_here = _impl.change_parity_here
cleanup_parity = _impl.cleanup_parity
cleanup_parity_here = _impl.cleanup_parity_here
colorize_parity = _impl.colorize_parity
colorize_parity_here = _impl.colorize_parity_here
reduce_parity = _impl.reduce_parity
reduce_parity_here = _impl.reduce_parity_here
class reduce_parity_data(object):
    r"""
    Internal data computed by the reduce_parity function

    `piprime1` and `piprime2` have the size of `aut`'s edge vector,
    represent two possible colorations of the edges.  piprime1 assumes
    that terminal cases of the recursion are odd, and piprime2 assumes
    they are even.

    reduce_parity() actually compares the range of values in these
    two vectors to limit the number of colors.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    parity_max = property(_impl.reduce_parity_data_parity_max_get, _impl.reduce_parity_data_parity_max_set, doc=r"""Whether the input automaton is parity max""")
    parity_odd = property(_impl.reduce_parity_data_parity_odd_get, _impl.reduce_parity_data_parity_odd_set, doc=r"""Whether the input automaton is parity odd""")
    piprime1 = property(_impl.reduce_parity_data_piprime1_get, _impl.reduce_parity_data_piprime1_set, doc=r"""Coloring assuming odd terminal base cases.""")
    piprime2 = property(_impl.reduce_parity_data_piprime2_get, _impl.reduce_parity_data_piprime2_set, doc=r"""Coloring assuming even terminal base cases.""")

    def __init__(self, aut, layered=False):
        r"""Compute parity reduction data for *aut*."""
        _impl.reduce_parity_data_swiginit(self, _impl.new_reduce_parity_data(aut, layered))
    __swig_destroy__ = _impl.delete_reduce_parity_data

# Register reduce_parity_data in _impl:
_impl.reduce_parity_data_swigregister(reduce_parity_data)
class postprocessor(object):
    r"""
    Wrap TGBA/BA/Monitor post-processing algorithms in an
    easy interface.

    This class is a shell around scc_filter(),
    minimize_obligation(), simulation(), iterated_simulations(),
    degeneralize(), to_generalized_buchi(), tgba_determinize(), and
    other algorithms.  These different algorithms will be combined
    depending on the various options set with set_type(),
    set_pref(), and set_level().

    This helps hiding some of the logic required to combine these
    simplifications efficiently (e.g., there is no point calling
    degeneralize() or any simulation when minimize_obligation()
    succeeded.)

    Use set_type() to select desired output type.

    Use the set_pref() method to specify whether you favor
    deterministic automata or small automata.  If you don't care,
    less post processing will be done.

    The set_level() method lets you set the optimization level.
    A higher level enables more costly post-processings.  For instance
    pref=Small,level=High will try two different post-processings
    (one with minimize_obligation(), and one with
    iterated_simulations()) and keep the smallest result.
    pref=Small,level=Medium will only try the iterated_simulations()
    when minimized_obligation failed to produce an automaton smaller
    than its input.  pref=Small,level=Low will only run
    simulation().

    The handling of alternating automata should change in the
    future, but currently ``Generic``, ``Low``, ``Any`` is the only
    configuration where alternation is preserved.  In any other
    configuration, ``remove_alternation()`` will be called.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, opt=None):
        r"""
        Construct a postprocessor.

        The *opt* argument can be used to pass extra fine-tuning
        options used for debugging or benchmarking.
        """
        _impl.postprocessor_swiginit(self, _impl.new_postprocessor(opt))
    TGBA = _impl.postprocessor_TGBA
    GeneralizedBuchi = _impl.postprocessor_GeneralizedBuchi
    BA = _impl.postprocessor_BA
    Monitor = _impl.postprocessor_Monitor
    Generic = _impl.postprocessor_Generic
    Parity = _impl.postprocessor_Parity
    ParityMin = _impl.postprocessor_ParityMin
    ParityMax = _impl.postprocessor_ParityMax
    ParityOdd = _impl.postprocessor_ParityOdd
    ParityEven = _impl.postprocessor_ParityEven
    ParityMinOdd = _impl.postprocessor_ParityMinOdd
    ParityMaxOdd = _impl.postprocessor_ParityMaxOdd
    ParityMinEven = _impl.postprocessor_ParityMinEven
    ParityMaxEven = _impl.postprocessor_ParityMaxEven
    CoBuchi = _impl.postprocessor_CoBuchi
    Buchi = _impl.postprocessor_Buchi
    Finite = _impl.postprocessor_Finite
    set_type = _swig_new_instance_method(_impl.postprocessor_set_type)
    Any = _impl.postprocessor_Any
    Small = _impl.postprocessor_Small
    Deterministic = _impl.postprocessor_Deterministic
    Complete = _impl.postprocessor_Complete
    SBAcc = _impl.postprocessor_SBAcc
    Unambiguous = _impl.postprocessor_Unambiguous
    Colored = _impl.postprocessor_Colored
    Obligation = _impl.postprocessor_Obligation
    set_pref = _swig_new_instance_method(_impl.postprocessor_set_pref)
    Low = _impl.postprocessor_Low
    Medium = _impl.postprocessor_Medium
    High = _impl.postprocessor_High
    set_level = _swig_new_instance_method(_impl.postprocessor_set_level)
    run = _swig_new_instance_method(_impl.postprocessor_run)
    __swig_destroy__ = _impl.delete_postprocessor

# Register postprocessor in _impl:
_impl.postprocessor_swigregister(postprocessor)
class power_map(object):
    r"""
    Maps each powerset-construction state to the set of original
    states it represents.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    map_ = property(_impl.power_map_map__get, _impl.power_map_map__set, doc=r"""Map from DFA states to NFA state sets.""")
    states_of = _swig_new_instance_method(_impl.power_map_states_of)

    def __init__(self):
        _impl.power_map_swiginit(self, _impl.new_power_map())
    __swig_destroy__ = _impl.delete_power_map

# Register power_map in _impl:
_impl.power_map_swigregister(power_map)
class output_aborter(object):
    r"""
    Helper object to specify when an algorithm
    should abort its construction.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""Construct with max states and max edges limits."""
        _impl.output_aborter_swiginit(self, _impl.new_output_aborter(*args))
    max_states = _swig_new_instance_method(_impl.output_aborter_max_states)
    max_edges = _swig_new_instance_method(_impl.output_aborter_max_edges)
    too_large = _swig_new_instance_method(_impl.output_aborter_too_large)
    print_reason = _swig_new_instance_method(_impl.output_aborter_print_reason)
    __swig_destroy__ = _impl.delete_output_aborter

# Register output_aborter in _impl:
_impl.output_aborter_swigregister(output_aborter)
tgba_powerset = _impl.tgba_powerset
tba_determinize = _impl.tba_determinize
tba_determinize_check = _impl.tba_determinize_check
product_susp = _impl.product_susp
product_or_susp = _impl.product_or_susp
split_edges = _impl.split_edges
class edge_separator(object):
    r"""
    separate edges so that their labels are disjoint

    To use this class, first call add_to_basis() for each label that
    you want to separate.  Then call separate() to get a new
    automaton.

    Note that all labels seen by separate() should have been
    previously declared using add_to_basis(), but more can be
    declared.

    For instance an automaton has labels in {a,b,!a&!b&c} and those
    are used as basis, the separated automaton should have its
    labels among {a&!b,a&b,!a&b,!a&!b&c}.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    add_to_basis = _swig_new_instance_method(_impl.edge_separator_add_to_basis)
    separate_implying = _swig_new_instance_method(_impl.edge_separator_separate_implying)
    separate_compat = _swig_new_instance_method(_impl.edge_separator_separate_compat)
    basis_size = _swig_new_instance_method(_impl.edge_separator_basis_size)
    basis = _swig_new_instance_method(_impl.edge_separator_basis)

    def __init__(self):
        _impl.edge_separator_swiginit(self, _impl.new_edge_separator())
    __swig_destroy__ = _impl.delete_edge_separator

# Register edge_separator in _impl:
_impl.edge_separator_swigregister(edge_separator)
separate_edges = _impl.separate_edges
sum = _impl.sum
sum_and = _impl.sum_and
sl = _impl.sl
sl2_inplace = _impl.sl2_inplace
sl2 = _impl.sl2
closure_inplace = _impl.closure_inplace
closure = _impl.closure
is_stutter_invariant = _impl.is_stutter_invariant
check_stutter_invariance = _impl.check_stutter_invariance
stutter_invariant_states = _impl.stutter_invariant_states
highlight_stutter_invariant_states = _impl.highlight_stutter_invariant_states
stutter_invariant_letters = _impl.stutter_invariant_letters
is_stutter_invariant_forward_closed = _impl.is_stutter_invariant_forward_closed
make_stutter_invariant_forward_closed_inplace = _impl.make_stutter_invariant_forward_closed_inplace
class synthesis_info(object):
    r"""Benchmarking data and options for synthesis"""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    algo_DET_SPLIT = _impl.synthesis_info_algo_DET_SPLIT
    algo_SPLIT_DET = _impl.synthesis_info_algo_SPLIT_DET
    algo_DPA_SPLIT = _impl.synthesis_info_algo_DPA_SPLIT
    algo_LAR = _impl.synthesis_info_algo_LAR
    algo_LAR_OLD = _impl.synthesis_info_algo_LAR_OLD
    algo_ACD = _impl.synthesis_info_algo_ACD
    splittype_AUTO = _impl.synthesis_info_splittype_AUTO
    splittype_EXPL = _impl.synthesis_info_splittype_EXPL
    splittype_SEMISYM = _impl.synthesis_info_splittype_SEMISYM
    splittype_FULLYSYM = _impl.synthesis_info_splittype_FULLYSYM

    def __init__(self):
        _impl.synthesis_info_swiginit(self, _impl.new_synthesis_info())
    force_sbacc = property(_impl.synthesis_info_force_sbacc_get, _impl.synthesis_info_force_sbacc_set, doc=r"""Force state-based acceptance.""")
    s = property(_impl.synthesis_info_s_get, _impl.synthesis_info_s_set, doc=r"""Selected algorithm.""")
    minimize_lvl = property(_impl.synthesis_info_minimize_lvl_get, _impl.synthesis_info_minimize_lvl_set, doc=r"""Minimization level.""")
    sp = property(_impl.synthesis_info_sp_get, _impl.synthesis_info_sp_set, doc=r"""Splitting strategy.""")
    bv = property(_impl.synthesis_info_bv_get, _impl.synthesis_info_bv_set, doc=r"""Benchmarking data.""")
    verbose_stream = property(_impl.synthesis_info_verbose_stream_get, _impl.synthesis_info_verbose_stream_set, doc=r"""Verbose output stream.""")
    opt = property(_impl.synthesis_info_opt_get, _impl.synthesis_info_opt_set, doc=r"""Additional options.""")
    moore = property(_impl.synthesis_info_moore_get, _impl.synthesis_info_moore_set, doc=r"""Use Moore (output-first) semantics instead of Mealy.""")
    dict = property(_impl.synthesis_info_dict_get, _impl.synthesis_info_dict_set, doc=r"""BDD dictionary.""")
    __swig_destroy__ = _impl.delete_synthesis_info

# Register synthesis_info in _impl:
_impl.synthesis_info_swigregister(synthesis_info)
split_2step = _impl.split_2step
unsplit_2step = _impl.unsplit_2step
ltl_to_game = _impl.ltl_to_game
solved_game_to_mealy = _impl.solved_game_to_mealy
solved_game_to_separated_mealy = _impl.solved_game_to_separated_mealy
solved_game_to_split_mealy = _impl.solved_game_to_split_mealy
class mealy_like(object):
    r"""
    A struct that represents different types of mealy like
           objects
    """

    thisown = 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
    realizability_code_UNREALIZABLE = _impl.mealy_like_realizability_code_UNREALIZABLE
    realizability_code_UNKNOWN = _impl.mealy_like_realizability_code_UNKNOWN
    realizability_code_REALIZABLE_REGULAR = _impl.mealy_like_realizability_code_REALIZABLE_REGULAR
    realizability_code_REALIZABLE_DTGBA = _impl.mealy_like_realizability_code_REALIZABLE_DTGBA
    success = property(_impl.mealy_like_success_get, _impl.mealy_like_success_set, doc=r"""Realizability result.""")
    mealy_like = property(_impl.mealy_like_mealy_like_get, _impl.mealy_like_mealy_like_set)
    glob_cond = property(_impl.mealy_like_glob_cond_get, _impl.mealy_like_glob_cond_set, doc=r"""Global condition for DTGBA strategies.""")
    __swig_destroy__ = _impl.delete_mealy_like

# Register mealy_like in _impl:
_impl.mealy_like_swigregister(mealy_like)
split_independent_formulas = _impl.split_independent_formulas
try_create_direct_strategy = _impl.try_create_direct_strategy
solve_game = _impl.solve_game
class game_relabeling_map(object):
    r"""
    Pair of relabeling maps for environment and player edges in a
    synthesis game.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    env_map = property(_impl.game_relabeling_map_env_map_get, _impl.game_relabeling_map_env_map_set, doc=r"""Map for environment edges.""")
    player_map = property(_impl.game_relabeling_map_player_map_get, _impl.game_relabeling_map_player_map_set, doc=r"""Map for player edges.""")

    def __init__(self):
        _impl.game_relabeling_map_swiginit(self, _impl.new_game_relabeling_map())
    __swig_destroy__ = _impl.delete_game_relabeling_map

# Register game_relabeling_map in _impl:
_impl.game_relabeling_map_swigregister(game_relabeling_map)
partitioned_game_relabel_here = _impl.partitioned_game_relabel_here
relabel_game_here = _impl.relabel_game_here
class translator(object):
    r"""
    Translate an LTL formula into an optimized 'twa_graph'.

    This class implements a three-step translation:
    - syntactic simplification of the formula
    - translation of the formula into TGBA
    - postprocessing of the resulting TGBA to minimize it, or
      turn it into the required form.

    Method set_type() may be used to specify the type of
    automaton produced (TGBA, BA, Monitor).  The default is TGBA.

    Method set_pref() may be used to specify whether small automata
    should be preferred over deterministic automata.

    Method set_level() may be used to specify the optimization level.

    The semantic of these three methods is inherited from the
    postprocessor class, but the optimization level is
    additionally used to select which LTL simplifications to enable.

    Most of the techniques used to produce TGBA or BA are described
    in "LTL translation improvements in Spot 1.0" (Alexandre
    Duret-Lutz. Int. J. on Critical Computer-Based Systems, 5(1/2),
    pp. 31–54, March 2014).

    Unambiguous automata are produced using a trick described in
    "LTL Model Checking of Interval Markov Chains" (Michael Benedikt
    and Rastislav Lenhardt and James Worrell, Proceedings of
    TACAS'13, pp. 32–46, LNCS 7795).

    For reference about formula simplifications, see
    https://spot.lrde.epita.fr/tl.pdf (a copy of this file should be
    in the doc/tl/ subdirectory of the Spot sources).

    For reference and documentation about the post-processing step,
    see the documentation of the 'postprocessor' class.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        *Overload 1:*
        Construct a translator with a given simplifier.

        |

        *Overload 2:*
        Construct a translator with a given BDD dictionary.

        |

        *Overload 3:*
        Construct a translator with a given BDD dictionary.

        |

        *Overload 4:*
        Construct a translator with optional options.

        |

        *Overload 5:*
        Construct a translator with optional options.
        """
        _impl.translator_swiginit(self, _impl.new_translator(*args))
    __swig_destroy__ = _impl.delete_translator
    set_type = _swig_new_instance_method(_impl.translator_set_type)
    set_pref = _swig_new_instance_method(_impl.translator_set_pref)
    set_level = _swig_new_instance_method(_impl.translator_set_level)
    run = _swig_new_instance_method(_impl.translator_run)
    clear_caches = _swig_new_instance_method(_impl.translator_clear_caches)

# Register translator in _impl:
_impl.translator_swigregister(translator)
to_weak_alternating = _impl.to_weak_alternating
print_hoa = _impl.print_hoa
get_aliases = _impl.get_aliases
set_aliases = _impl.set_aliases
class hoa_alias_formater(object):
    r"""Help printing BDDs as text, using aliases."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, aut, false_str, true_str, or_str, and_str, not_str, lpar_str, rpar_str, ap_printer):
        r"""
        Initialize this class from the aliases defined
        for an automaton.

        The aliases are taken from the named-property "aliases",
        defined in the automaton.  If no such named-property exist,
        the aliases() method will return a null pointer.

        Note that any alias that uses an atomic proposition not
        registered in the automaton is not only ignored, but also
        removed from the alias list stored in the automaton.

        The *or_str*, *and_str*, and *ap_printer* arguments are
        used to print operators OR, AND, and to print atomic propositions
        that are not aliases.  *lpar_str* and *rpar_str* are used
        to group conjuncts that appear in a disjunction.
        """
        _impl.hoa_alias_formater_swiginit(self, _impl.new_hoa_alias_formater(aut, false_str, true_str, or_str, and_str, not_str, lpar_str, rpar_str, ap_printer))
    encode_label = _swig_new_instance_method(_impl.hoa_alias_formater_encode_label)
    aliases = _swig_new_instance_method(_impl.hoa_alias_formater_aliases)
    __swig_destroy__ = _impl.delete_hoa_alias_formater

# Register hoa_alias_formater in _impl:
_impl.hoa_alias_formater_swigregister(hoa_alias_formater)
create_alias_basis = _impl.create_alias_basis
dtwa_sat_synthetize = _impl.dtwa_sat_synthetize
dtwa_sat_minimize = _impl.dtwa_sat_minimize
dtwa_sat_minimize_dichotomy = _impl.dtwa_sat_minimize_dichotomy
dtwa_sat_minimize_incr = _impl.dtwa_sat_minimize_incr
dtwa_sat_minimize_assume = _impl.dtwa_sat_minimize_assume
sat_minimize = _impl.sat_minimize
class mtdswa(object):
    r"""
    Algorithms and data structures for MTBDD-based ω-automata.

    MTBDD-based representation of a state-based ω-automaton.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, dict):
        r"""Construct an MTDSwA with the given BDD dictionary."""
        _impl.mtdswa_swiginit(self, _impl.new_mtdswa(dict))
    __swig_destroy__ = _impl.delete_mtdswa
    aps = property(_impl.mtdswa_aps_get, _impl.mtdswa_aps_set, doc=r"""
    The list of atomic propositions possibly used by the automaton.

    This is actually the list of atomic propositions that appeared
    in the formulas/automata that were used to build this
    automaton.  The automaton itself may use fewer atomic
    propositions, for instance in case some of them cancel each other.

    This vector is sorted by formula ID, to make it easy to merge
    with another sorted vector.
    """)
    states = property(_impl.mtdswa_states_get, _impl.mtdswa_states_set, doc=r"""BDD transitions for each root state.""")
    names = property(_impl.mtdswa_names_get, _impl.mtdswa_names_set, doc=r"""Name formula for each root state.""")
    colors = property(_impl.mtdswa_colors_get, _impl.mtdswa_colors_set, doc=r"""Acceptance marks per root state.""")
    acc = property(_impl.mtdswa_acc_get, _impl.mtdswa_acc_set, doc=r"""Acceptance condition of the automaton.""")
    terminal_to_state_map = property(_impl.mtdswa_terminal_to_state_map_get, _impl.mtdswa_terminal_to_state_map_set, doc=r"""Map terminal BDD values to state indices (debug only).""")
    highlight_nodes = property(_impl.mtdswa_highlight_nodes_get, _impl.mtdswa_highlight_nodes_set, doc=r"""Highlighted BDD nodes (for visualization).""")
    highlight_groups = property(_impl.mtdswa_highlight_groups_get, _impl.mtdswa_highlight_groups_set, doc=r"""Cluster grouping for BDD nodes (for visualization).""")
    get_dict = _swig_new_instance_method(_impl.mtdswa_get_dict)
    num_roots = _swig_new_instance_method(_impl.mtdswa_num_roots)
    num_states = _swig_new_instance_method(_impl.mtdswa_num_states)
    print_dot = _swig_new_instance_method(_impl.mtdswa_print_dot)
    as_twa = _swig_new_instance_method(_impl.mtdswa_as_twa)
    sinks_as_states = _swig_new_instance_method(_impl.mtdswa_sinks_as_states)
    sinks_as_constants = _swig_new_instance_method(_impl.mtdswa_sinks_as_constants)
    set_controllable_variables = _swig_new_instance_method(_impl.mtdswa_set_controllable_variables)
    get_controllable_variables = _swig_new_instance_method(_impl.mtdswa_get_controllable_variables)

# Register mtdswa in _impl:
_impl.mtdswa_swigregister(mtdswa)
dtwa_to_mtdswa = _impl.dtwa_to_mtdswa
scc_vector = _impl.scc_vector
loding_weak_ranking = _impl.loding_weak_ranking
minimize_mtdswa = _impl.minimize_mtdswa
product = _impl.product
product_or = _impl.product_or
product_xor = _impl.product_xor
product_xnor = _impl.product_xnor
product_implies = _impl.product_implies
quantify_exists = _impl.quantify_exists
quantify_forall = _impl.quantify_forall
class simple_ltl_translator(object):
    r"""
    "Semi-internal" for translating LTL using MTBDDs

    It is public only to make it possible to demonstrate the inner
    working of the translation.  Do not rely on the interface to be
    stable.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, dict, simplify_terms=True):
        r"""Construct the translator with the given BDD dictionary."""
        _impl.simple_ltl_translator_swiginit(self, _impl.new_simple_ltl_translator(dict, simplify_terms))
    ltl_to_mtdswa = _swig_new_instance_method(_impl.simple_ltl_translator_ltl_to_mtdswa)
    ltl_to_mtdswa_synthesis = _swig_new_instance_method(_impl.simple_ltl_translator_ltl_to_mtdswa_synthesis)
    ltl_to_mtbdd = _swig_new_instance_method(_impl.simple_ltl_translator_ltl_to_mtbdd)
    leaf_to_formula = _swig_new_instance_method(_impl.simple_ltl_translator_leaf_to_formula)
    terminal_to_formula = _swig_new_instance_method(_impl.simple_ltl_translator_terminal_to_formula)
    formula_to_int = _swig_new_instance_method(_impl.simple_ltl_translator_formula_to_int)
    formula_propeq_to_int = _swig_new_instance_method(_impl.simple_ltl_translator_formula_propeq_to_int)
    formula_to_terminal = _swig_new_instance_method(_impl.simple_ltl_translator_formula_to_terminal)
    formula_to_terminal_bdd = _swig_new_instance_method(_impl.simple_ltl_translator_formula_to_terminal_bdd)
    formula_to_terminal_bdd_as_int = _swig_new_instance_method(_impl.simple_ltl_translator_formula_to_terminal_bdd_as_int)
    formula_propeq_to_terminal_bdd_as_int = _swig_new_instance_method(_impl.simple_ltl_translator_formula_propeq_to_terminal_bdd_as_int)
    combine_and = _swig_new_instance_method(_impl.simple_ltl_translator_combine_and)
    combine_or = _swig_new_instance_method(_impl.simple_ltl_translator_combine_or)
    combine_implies = _swig_new_instance_method(_impl.simple_ltl_translator_combine_implies)
    combine_equiv = _swig_new_instance_method(_impl.simple_ltl_translator_combine_equiv)
    combine_xor = _swig_new_instance_method(_impl.simple_ltl_translator_combine_xor)
    combine_not = _swig_new_instance_method(_impl.simple_ltl_translator_combine_not)
    propeq_encode = _swig_new_instance_method(_impl.simple_ltl_translator_propeq_encode)
    propeq_representative = _swig_new_instance_method(_impl.simple_ltl_translator_propeq_representative)
    get_cache = _swig_new_instance_method(_impl.simple_ltl_translator_get_cache)
    __swig_destroy__ = _impl.delete_simple_ltl_translator

# Register simple_ltl_translator in _impl:
_impl.simple_ltl_translator_swigregister(simple_ltl_translator)
obligation_to_mtdswa = _impl.obligation_to_mtdswa
obligation_synthesis = _impl.obligation_synthesis
mtdswa_strategy_to_mealy = _impl.mtdswa_strategy_to_mealy
trim = _impl.trim
class mtdtwa(object):
    r"""A multi-terminal decision diagram representation of a TωA."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, dict):
        r"""Construct an MTDTwA with the given BDD dictionary."""
        _impl.mtdtwa_swiginit(self, _impl.new_mtdtwa(dict))
    __swig_destroy__ = _impl.delete_mtdtwa
    states = property(_impl.mtdtwa_states_get, _impl.mtdtwa_states_set, doc=r"""BDD transitions for each root state.""")
    acc = property(_impl.mtdtwa_acc_get, _impl.mtdtwa_acc_set, doc=r"""Acceptance condition of the automaton.""")
    dict_ = property(_impl.mtdtwa_dict__get, _impl.mtdtwa_dict__set, doc=r"""BDD dictionary.""")
    terminal_data_map = property(_impl.mtdtwa_terminal_data_map_get, _impl.mtdtwa_terminal_data_map_set, doc=r"""Map from terminal BDD values to data.""")
    num_roots = _swig_new_instance_method(_impl.mtdtwa_num_roots)
    print_dot = _swig_new_instance_method(_impl.mtdtwa_print_dot)
    as_twa = _swig_new_instance_method(_impl.mtdtwa_as_twa)

# Register mtdtwa in _impl:
_impl.mtdtwa_swigregister(mtdtwa)
dtwa_to_mtdtwa = _impl.dtwa_to_mtdtwa
relabel_here = _impl.relabel_here
partitioned_relabel_here = _impl.partitioned_relabel_here
class twa_word(object):
    r"""
    An infinite word stored as a lasso.

    This is not exactly a word in the traditional sense because we
    use boolean formulas instead of letters.  So technically a
    twa_word can represent a set of words.

    This class only represents lasso-shaped words using two lists of
    BDDs: one list of the prefix, one list for the cycle.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        *Overload 1:*
        Construct an empty word with the given BDD dictionary.

        |

        *Overload 2:*
        Construct a word from a twa_run.
        """
        _impl.twa_word_swiginit(self, _impl.new_twa_word(*args))
    __swig_destroy__ = _impl.delete_twa_word
    simplify = _swig_new_instance_method(_impl.twa_word_simplify)
    use_all_aps = _swig_new_instance_method(_impl.twa_word_use_all_aps)
    prefix = property(_impl.twa_word_prefix_get, _impl.twa_word_prefix_set, doc=r"""Finite prefix of the word.""")
    cycle = property(_impl.twa_word_cycle_get, _impl.twa_word_cycle_set, doc=r"""Infinite repeating cycle of the word.""")
    get_dict = _swig_new_instance_method(_impl.twa_word_get_dict)
    as_automaton = _swig_new_instance_method(_impl.twa_word_as_automaton)
    intersects = _swig_new_instance_method(_impl.twa_word_intersects)
    __str__ = _swig_new_instance_method(_impl.twa_word___str__)

# Register twa_word in _impl:
_impl.twa_word_swigregister(twa_word)
__lshift__ = _impl.__lshift__

make_twa_word = _impl.make_twa_word
parse_word = _impl.parse_word
class lasso_enumerator(object):
    r"""
    Lazily enumerate lasso-shaped accepted runs/words of bounded size.

    A lasso consists of a finite stem path followed by an infinite cycle.
    Given bounds on the stem and cycle lengths, this class enumerates all
    accepted lasso-shaped runs in order of increasing total length
    (stem + cycle), breaking ties by shorter stem first.

    All acceptance conditions are supported.

    If the automaton is non-deterministic, the enumeration does not remove
    duplicate words or runs.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, aut, min_stem, max_stem, min_cycle, max_cycle):
        r"""
        Construct a lasso enumerator.

        :type aut: :py:class:`twa_graph`
        :param aut:       automaton with any acceptance condition
        :type min_stem: int
        :param min_stem:  minimum stem length (≥0)
        :type max_stem: int
        :param max_stem:  maximum stem length (≥min_stem; UINT_MAX = unbounded)
        :type min_cycle: int
        :param min_cycle: minimum cycle length (≥1)
        :type max_cycle: int
        :param max_cycle: maximum cycle length (≥min_cycle; UINT_MAX = unbounded)

        :raises: std::invalid_argument if the bounds are inconsistent.
        """
        _impl.lasso_enumerator_swiginit(self, _impl.new_lasso_enumerator(aut, min_stem, max_stem, min_cycle, max_cycle))
    __swig_destroy__ = _impl.delete_lasso_enumerator
    next_run = _swig_new_instance_method(_impl.lasso_enumerator_next_run)
    next_word = _swig_new_instance_method(_impl.lasso_enumerator_next_word)

# Register lasso_enumerator in _impl:
_impl.lasso_enumerator_swigregister(lasso_enumerator)
class list_bdd(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_impl.list_bdd_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_impl.list_bdd___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.list_bdd___bool__)
    __len__ = _swig_new_instance_method(_impl.list_bdd___len__)
    __getslice__ = _swig_new_instance_method(_impl.list_bdd___getslice__)
    __setslice__ = _swig_new_instance_method(_impl.list_bdd___setslice__)
    __delslice__ = _swig_new_instance_method(_impl.list_bdd___delslice__)
    __delitem__ = _swig_new_instance_method(_impl.list_bdd___delitem__)
    __getitem__ = _swig_new_instance_method(_impl.list_bdd___getitem__)
    __setitem__ = _swig_new_instance_method(_impl.list_bdd___setitem__)
    pop = _swig_new_instance_method(_impl.list_bdd_pop)
    append = _swig_new_instance_method(_impl.list_bdd_append)
    empty = _swig_new_instance_method(_impl.list_bdd_empty)
    size = _swig_new_instance_method(_impl.list_bdd_size)
    swap = _swig_new_instance_method(_impl.list_bdd_swap)
    begin = _swig_new_instance_method(_impl.list_bdd_begin)
    end = _swig_new_instance_method(_impl.list_bdd_end)
    rbegin = _swig_new_instance_method(_impl.list_bdd_rbegin)
    rend = _swig_new_instance_method(_impl.list_bdd_rend)
    clear = _swig_new_instance_method(_impl.list_bdd_clear)
    get_allocator = _swig_new_instance_method(_impl.list_bdd_get_allocator)
    pop_back = _swig_new_instance_method(_impl.list_bdd_pop_back)
    erase = _swig_new_instance_method(_impl.list_bdd_erase)

    def __init__(self, *args):
        _impl.list_bdd_swiginit(self, _impl.new_list_bdd(*args))
    push_back = _swig_new_instance_method(_impl.list_bdd_push_back)
    front = _swig_new_instance_method(_impl.list_bdd_front)
    back = _swig_new_instance_method(_impl.list_bdd_back)
    assign = _swig_new_instance_method(_impl.list_bdd_assign)
    resize = _swig_new_instance_method(_impl.list_bdd_resize)
    insert = _swig_new_instance_method(_impl.list_bdd_insert)
    pop_front = _swig_new_instance_method(_impl.list_bdd_pop_front)
    push_front = _swig_new_instance_method(_impl.list_bdd_push_front)
    reverse = _swig_new_instance_method(_impl.list_bdd_reverse)
    __swig_destroy__ = _impl.delete_list_bdd

# Register list_bdd in _impl:
_impl.list_bdd_swigregister(list_bdd)
class isomorphism_checker(object):
    r"""Check if two automata are isomorphic."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, ref):
        r"""Construct the checker with *ref* as the reference automaton."""
        _impl.isomorphism_checker_swiginit(self, _impl.new_isomorphism_checker(ref))
    is_isomorphic = _swig_new_instance_method(_impl.isomorphism_checker_is_isomorphic)
    are_isomorphic = _swig_new_static_method(_impl.isomorphism_checker_are_isomorphic)
    __swig_destroy__ = _impl.delete_isomorphism_checker

# Register isomorphism_checker in _impl:
_impl.isomorphism_checker_swigregister(isomorphism_checker)
class to_parity_data(object):
    r"""
    Structure used by to_parity to store some information about
    the construction.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    nb_states_created = property(_impl.to_parity_data_nb_states_created_get, _impl.to_parity_data_nb_states_created_set, doc=r"""Total number of states created""")
    nb_edges_created = property(_impl.to_parity_data_nb_edges_created_get, _impl.to_parity_data_nb_edges_created_set, doc=r"""Total number of edges created""")
    algorithms_used = property(_impl.to_parity_data_algorithms_used_get, _impl.to_parity_data_algorithms_used_set, doc=r"""Name of algorithms used""")

    def __init__(self):
        _impl.to_parity_data_swiginit(self, _impl.new_to_parity_data())
    __swig_destroy__ = _impl.delete_to_parity_data

# Register to_parity_data in _impl:
_impl.to_parity_data_swigregister(to_parity_data)
class to_parity_options(object):
    r"""Options to control various optimizations of to_parity()."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    search_ex = property(_impl.to_parity_options_search_ex_get, _impl.to_parity_options_search_ex_set, doc=r"""
    If ``search_ex`` is true, whenever CAR or IAR have to move
    several elements in a record, it tries to find an order such
    that the new permutation already exists.
    """)
    use_last = property(_impl.to_parity_options_use_last_get, _impl.to_parity_options_use_last_set, doc=r"""
    If ``use_last`` is true and *search_ex* are true, we use the
    most recent state when we find multiple existing state
    compatible with the current move.
    """)
    use_last_post_process = property(_impl.to_parity_options_use_last_post_process_get, _impl.to_parity_options_use_last_post_process_set, doc=r"""
    If ``use_last_post_process`` is true, then when LAR ends, it tries to
    replace the destination of an edge by the newest compatible state.
    """)
    force_order = property(_impl.to_parity_options_force_order_get, _impl.to_parity_options_force_order_set, doc=r"""
    If ``force_order`` is true, we force to use an order when CAR or IAR is
    applied. Given a state s and a set E ({0}, {0 1}, {2} for example) we
    construct an order on colors. With the given example, we ask to have
    a permutation that start with [0 …], [0 1 …] or [2 …] in
     that order of preference.
    """)
    partial_degen = property(_impl.to_parity_options_partial_degen_get, _impl.to_parity_options_partial_degen_set, doc=r"""
    If ``partial_degen`` is true, apply a partial
    degeneralization to remove occurrences of acceptance
    subformulas such as `Fin(x) | Fin(y)` or `Inf(x) & Inf(y)`.
    """)
    acc_clean = property(_impl.to_parity_options_acc_clean_get, _impl.to_parity_options_acc_clean_set, doc=r"""
    If ``scc_acc_clean`` is true, to_parity() will ignore colors
    not occurring in an SCC while processing this SCC.
    """)
    parity_equiv = property(_impl.to_parity_options_parity_equiv_get, _impl.to_parity_options_parity_equiv_set, doc=r"""
    If ``parity_equiv`` is true, to_parity() will check if there
    exists a way to see the acceptance condition as a parity max one.
    """)
    car = property(_impl.to_parity_options_car_get, _impl.to_parity_options_car_set, doc=r"""
    If ``Car`` is true, to_parity will try to apply CAR. It is a version of
    LAR that tracks colors.
    """)
    tar = property(_impl.to_parity_options_tar_get, _impl.to_parity_options_tar_set, doc=r"""
    If ``tar`` is true, to_parity will try to apply TAR. It is a version of
    LAR that tracks transitions instead of colors.
    """)
    iar = property(_impl.to_parity_options_iar_get, _impl.to_parity_options_iar_set, doc=r"""If ``iar`` is true, to_parity will try to apply IAR.""")
    lar_dfs = property(_impl.to_parity_options_lar_dfs_get, _impl.to_parity_options_lar_dfs_set, doc=r"""
    if ``lar_dfs`` is true, then when LAR is used the next state of the
    result that will be processed is the last created state.
    """)
    bscc = property(_impl.to_parity_options_bscc_get, _impl.to_parity_options_bscc_set, doc=r"""
    If ``bscc`` is true, to_parity() will only keep the bottommost automaton
    when it applies LAR.
    """)
    parity_prefix = property(_impl.to_parity_options_parity_prefix_get, _impl.to_parity_options_parity_prefix_set, doc=r"""
    If ``parity_prefix`` is true, to_parity() will use a special
    handling for acceptance conditions of the form `Inf(m0) |
    (Fin(m1) & (Inf(m2) | (… β)))` that start as a parity
    condition (modulo a renumbering of `m0`, `m1`, `m2`, ...) but where
    `β` can be an arbitrary formula.  In this case, the paritization
    algorithm is really applied only to `β`, and the marks of the
    prefix are appended after a suitable renumbering.
    """)
    parity_prefix_general = property(_impl.to_parity_options_parity_prefix_general_get, _impl.to_parity_options_parity_prefix_general_set, doc=r"""
    If ``parity_prefix_general`` is true, to_parity() will rewrite the
    acceptance condition as `Inf(m0) | (Fin(m1) & (Inf(m2) | (… β)))` before
    applying the same construction as with the option ``parity_prefix``.
    """)
    generic_emptiness = property(_impl.to_parity_options_generic_emptiness_get, _impl.to_parity_options_generic_emptiness_set, doc=r"""
    If ``generic_emptiness`` is true, to_parity() will check if the automaton
    does not accept any word with an emptiness check algorithm.
    """)
    rabin_to_buchi = property(_impl.to_parity_options_rabin_to_buchi_get, _impl.to_parity_options_rabin_to_buchi_set, doc=r"""
    If ``rabin_to_buchi`` is true, to_parity() tries to convert a Rabin or
    Streett condition to Büchi or co-Büchi with
    rabin_to_buchi_if_realizable().
    """)
    buchi_type_to_buchi = property(_impl.to_parity_options_buchi_type_to_buchi_get, _impl.to_parity_options_buchi_type_to_buchi_set, doc=r"""
    If ``buchi_type_to_buchi`` is true, to_parity converts a
    (co-)Büchi type automaton to a (co-)Büchi automaton.
    """)
    parity_type_to_parity = property(_impl.to_parity_options_parity_type_to_parity_get, _impl.to_parity_options_parity_type_to_parity_set, doc=r"""
    If ``parity_type_to_parity`` is true, to_parity converts a
    parity type automaton to a parity automaton.
    """)
    reduce_col_deg = property(_impl.to_parity_options_reduce_col_deg_get, _impl.to_parity_options_reduce_col_deg_set, doc=r"""
    Only allow partial degeneralization if it reduces the number of colors
    in the acceptance condition or if it implies to apply IAR instead of
    CAR.
    """)
    propagate_col = property(_impl.to_parity_options_propagate_col_get, _impl.to_parity_options_propagate_col_set, doc=r"""
    Use propagate_marks_here to increase the number of marks on transition
    in order to move more colors (and increase the number of
    compatible states) when we apply LAR.
    """)
    use_generalized_rabin = property(_impl.to_parity_options_use_generalized_rabin_get, _impl.to_parity_options_use_generalized_rabin_set, doc=r"""
    If ``use_generalized_buchi`` is true, each SCC will use a generalized
    Rabin acceptance in order to avoid CAR.
    """)
    pretty_print = property(_impl.to_parity_options_pretty_print_get, _impl.to_parity_options_pretty_print_set, doc=r"""
    If ``pretty_print`` is true, states of the output automaton are
    named to help debugging.
    """)
    datas = property(_impl.to_parity_options_datas_get, _impl.to_parity_options_datas_set, doc=r"""Structure used to store some information about the construction.""")

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

# Register to_parity_options in _impl:
_impl.to_parity_options_swigregister(to_parity_options)
to_parity = _impl.to_parity
to_parity_old = _impl.to_parity_old
parity_type_to_parity = _impl.parity_type_to_parity
buchi_type_to_buchi = _impl.buchi_type_to_buchi
co_buchi_type_to_co_buchi = _impl.co_buchi_type_to_co_buchi
zielonka_tree_options_NONE = _impl.zielonka_tree_options_NONE
r"""Build the ZlkTree, without checking its shape."""
zielonka_tree_options_CHECK_RABIN = _impl.zielonka_tree_options_CHECK_RABIN
r"""
    Check if the ZlkTree has Rabin shape.
    This actually has no effect unless ABORT_WRONG_SHAPE is set,
    because zielonka_tree always check the shape.
    """
zielonka_tree_options_CHECK_STREETT = _impl.zielonka_tree_options_CHECK_STREETT
r"""
    Check if the ZlkTree has Streett shape.
    This actually has no effect unless ABORT_WRONG_SHAPE is set,
    because zielonka_tree always check the shape.
    """
zielonka_tree_options_CHECK_PARITY = _impl.zielonka_tree_options_CHECK_PARITY
r"""
    Check if the ZlkTree has Parity shape
    This actually has no effect unless ABORT_WRONG_SHAPE is set,
    because zielonka_tree always check the shape.
    """
zielonka_tree_options_ABORT_WRONG_SHAPE = _impl.zielonka_tree_options_ABORT_WRONG_SHAPE
r"""
    Abort the construction of the ZlkTree if it does not have the
    shape that is tested.  When that happens, num_branches() is set
    to 0.
    """
zielonka_tree_options_MERGE_SUBTREES = _impl.zielonka_tree_options_MERGE_SUBTREES
r"""
    Fuse identical subtrees.  This cannot be used with
    zielonka_tree_transform().  However it saves memory if the
    only use of the zielonka_tree to check the shape.
    """
zielonka_tree_options_NO_EMPTY_LAYER = _impl.zielonka_tree_options_NO_EMPTY_LAYER
r"""
    Do not store a layer for empty sets, to save space.
    You can check whether this layer is odd or even by calling
    empty_layer_is_even().
    """
class zielonka_tree(object):
    r"""
    Zielonka Tree implementation

    This class implements a Zielonka Tree, using
    conventions similar to those in 'casares.21.icalp'

    The difference is that this tree is built from Emerson-Lei
    acceptance conditions, and can be "walked through" with multiple
    colors at once.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""Build a Zielonka tree from the acceptance condition."""
        _impl.zielonka_tree_swiginit(self, _impl.new_zielonka_tree(*args))
    num_branches = _swig_new_instance_method(_impl.zielonka_tree_num_branches)
    first_branch = _swig_new_instance_method(_impl.zielonka_tree_first_branch)
    step = _swig_new_instance_method(_impl.zielonka_tree_step)
    is_even = _swig_new_instance_method(_impl.zielonka_tree_is_even)
    empty_layer_is_even = _swig_new_instance_method(_impl.zielonka_tree_empty_layer_is_even)
    has_rabin_shape = _swig_new_instance_method(_impl.zielonka_tree_has_rabin_shape)
    has_streett_shape = _swig_new_instance_method(_impl.zielonka_tree_has_streett_shape)
    has_parity_shape = _swig_new_instance_method(_impl.zielonka_tree_has_parity_shape)
    dot = _swig_new_instance_method(_impl.zielonka_tree_dot)
    nodes_ = property(_impl.zielonka_tree_nodes__get, _impl.zielonka_tree_nodes__set, doc=r"""All nodes of the Zielonka tree.""")
    __swig_destroy__ = _impl.delete_zielonka_tree

# Register zielonka_tree in _impl:
_impl.zielonka_tree_swigregister(zielonka_tree)
zielonka_tree_transform = _impl.zielonka_tree_transform
acd_options_NONE = _impl.acd_options_NONE
r"""Build the ACD, without checking its shape."""
acd_options_CHECK_RABIN = _impl.acd_options_CHECK_RABIN
r"""Check if the ACD has Rabin shape."""
acd_options_CHECK_STREETT = _impl.acd_options_CHECK_STREETT
r"""Check if the ACD has Streett shape."""
acd_options_CHECK_PARITY = _impl.acd_options_CHECK_PARITY
r"""Check if the ACD has Parity shape"""
acd_options_ABORT_WRONG_SHAPE = _impl.acd_options_ABORT_WRONG_SHAPE
r"""
    Abort the construction of the ACD if it does not have the
    shape that is tested.  When that happens, node_count() is set
    to 0.
    """
acd_options_ORDER_HEURISTIC = _impl.acd_options_ORDER_HEURISTIC
r"""
    Order the children of a node by decreasing size of the number
    of states they would introduce if that child appears as the
    last child of an "ACD" round in the state-based version of the
    ACD output.
    """
class acd(object):
    r"""
    Alternating Cycle Decomposition implementation

    This class implements an Alternating Cycle Decomposition
    similar to what is described in 'casares.21.icalp'

    The difference is that this ACD is built from Emerson-Lei
    acceptance conditions, and can be "walked through" with multiple
    colors at once.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        *Overload 1:*
        Build an Alternating Cycle Decomposition an SCC decomposition

        |

        *Overload 2:*
        Build an ACD directly from an automaton.

        |

        *Overload 3:*
        Build an ACD directly from an automaton.
        """
        _impl.acd_swiginit(self, _impl.new_acd(*args))
    __swig_destroy__ = _impl.delete_acd
    step = _swig_new_instance_method(_impl.acd_step)
    state_step = _swig_new_instance_method(_impl.acd_state_step)
    edges_of_node = _swig_new_instance_method(_impl.acd_edges_of_node)
    node_count = _swig_new_instance_method(_impl.acd_node_count)
    node_acceptance = _swig_new_instance_method(_impl.acd_node_acceptance)
    node_level = _swig_new_instance_method(_impl.acd_node_level)
    node_colors = _swig_new_instance_method(_impl.acd_node_colors)
    is_even = _swig_new_instance_method(_impl.acd_is_even)
    first_branch = _swig_new_instance_method(_impl.acd_first_branch)
    scc_max_level = _swig_new_instance_method(_impl.acd_scc_max_level)
    has_rabin_shape = _swig_new_instance_method(_impl.acd_has_rabin_shape)
    has_streett_shape = _swig_new_instance_method(_impl.acd_has_streett_shape)
    has_parity_shape = _swig_new_instance_method(_impl.acd_has_parity_shape)
    get_aut = _swig_new_instance_method(_impl.acd_get_aut)
    dot = _swig_new_instance_method(_impl.acd_dot)

# Register acd in _impl:
_impl.acd_swigregister(acd)
acd_transform = _impl.acd_transform
acd_transform_sbacc = _impl.acd_transform_sbacc
complement_semidet = _impl.complement_semidet
complement = _impl.complement
class fair_kripke_succ_iterator(twa_succ_iterator):
    r"""
    Iterator code for a Fair Kripke structure.

    This iterator can be used to simplify the writing
    of an iterator on a Fair Kripke structure (or lookalike).

    If you inherit from this iterator, you should only
    redefine

      - fair_kripke_succ_iterator::first()
      - fair_kripke_succ_iterator::next()
      - fair_kripke_succ_iterator::done()
      - fair_kripke_succ_iterator::dst()

    This class implements fair_kripke_succ_iterator::cond(),
    and fair_kripke_succ_iterator::acc().
    """

    thisown = 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

# Register fair_kripke_succ_iterator in _impl:
_impl.fair_kripke_succ_iterator_swigregister(fair_kripke_succ_iterator)
class fair_kripke(twa):
    r"""
    Interface for a Fair Kripke structure.

    A Kripke structure is a graph in which each node (=state) is
    labeled by a conjunction of atomic propositions, and a set of
    acceptance conditions.

    Such a structure can be seen as a 'twa' by pushing all labels
    to the outgoing transitions.

    A programmer that develops an instance of Fair Kripke structure
    needs to just provide an implementation for the following methods:

      - kripke::get_init_state()
      - kripke::succ_iter()
      - kripke::state_condition()
      - kripke::state_acceptance_conditions()
      - kripke::format_state()

    The other methods of the tgba interface are supplied by this
    class and need not be defined.

    See also 'fair_kripke_succ_iterator'.
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

# Register fair_kripke in _impl:
_impl.fair_kripke_swigregister(fair_kripke)
class kripke_succ_iterator(twa_succ_iterator):
    r"""
    Iterator code for Kripke structure

    This iterator can be used to simplify the writing
    of an iterator on a Kripke structure (or lookalike).

    If you inherit from this iterator, you should only
    redefine

      - kripke_succ_iterator::first()
      - kripke_succ_iterator::next()
      - kripke_succ_iterator::done()
      - kripke_succ_iterator::dst()

    This class implements kripke_succ_iterator::cond(),
    and kripke_succ_iterator::acc().
    """

    thisown = 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
    recycle = _swig_new_instance_method(_impl.kripke_succ_iterator_recycle)
    __swig_destroy__ = _impl.delete_kripke_succ_iterator

# Register kripke_succ_iterator in _impl:
_impl.kripke_succ_iterator_swigregister(kripke_succ_iterator)
class kripke(fair_kripke):
    r"""
    Interface for a Kripke structure

    A Kripke structure is a graph in which each node (=state) is
    labeled by a conjunction of atomic proposition.

    Such a structure can be seen as a 'twa' without
    any acceptance condition.

    A programmer that develops an instance of Kripke structure needs
    to just provide an implementation for the following methods:

      - kripke::get_init_state()
      - kripke::succ_iter()
      - kripke::state_condition()
      - kripke::format_state()

    The other methods of the tgba interface (like those dealing with
    acceptance conditions) are supplied by this kripke class and
    need not be defined.

    See also 'kripke_succ_iterator'.
    """

    thisown = 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

# Register kripke in _impl:
_impl.kripke_swigregister(kripke)
class kripke_graph_state(state):
    r"""Concrete class for kripke_graph states."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        *Overload 1:*
        Construct with BDD condition cond.

        |

        *Overload 2:*
        Copy constructor.
        """
        _impl.kripke_graph_state_swiginit(self, _impl.new_kripke_graph_state(*args))
    __swig_destroy__ = _impl.delete_kripke_graph_state
    clone = _swig_new_instance_method(_impl.kripke_graph_state_clone)
    cond = _swig_new_instance_method(_impl.kripke_graph_state_cond)

# Register kripke_graph_state in _impl:
_impl.kripke_graph_state_swigregister(kripke_graph_state)
class kripke_graph(kripke):
    r"""Kripke Structure."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, d):
        r"""Construct with BDD dictionary d."""
        _impl.kripke_graph_swiginit(self, _impl.new_kripke_graph(d))
    __swig_destroy__ = _impl.delete_kripke_graph
    num_states = _swig_new_instance_method(_impl.kripke_graph_num_states)
    num_edges = _swig_new_instance_method(_impl.kripke_graph_num_edges)
    set_init_state = _swig_new_instance_method(_impl.kripke_graph_set_init_state)
    get_init_state_number = _swig_new_instance_method(_impl.kripke_graph_get_init_state_number)
    get_init_state = _swig_new_instance_method(_impl.kripke_graph_get_init_state)
    succ_iter = _swig_new_instance_method(_impl.kripke_graph_succ_iter)
    state_number = _swig_new_instance_method(_impl.kripke_graph_state_number)
    state_from_number = _swig_new_instance_method(_impl.kripke_graph_state_from_number)
    format_state = _swig_new_instance_method(_impl.kripke_graph_format_state)
    edge_storage = _swig_new_instance_method(_impl.kripke_graph_edge_storage)
    new_state = _swig_new_instance_method(_impl.kripke_graph_new_state)
    new_states = _swig_new_instance_method(_impl.kripke_graph_new_states)
    new_edge = _swig_new_instance_method(_impl.kripke_graph_new_edge)
    states = _swig_new_instance_method(_impl.kripke_graph_states)
    edges = _swig_new_instance_method(_impl.kripke_graph_edges)
    out = _swig_new_instance_method(_impl.kripke_graph_out)

# Register kripke_graph in _impl:
_impl.kripke_graph_swigregister(kripke_graph)
make_kripke_graph = _impl.make_kripke_graph
class kripke_graph_state_out(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, g, t):
        _impl.kripke_graph_state_out_swiginit(self, _impl.new_kripke_graph_state_out(g, t))
    begin = _swig_new_instance_method(_impl.kripke_graph_state_out_begin)
    end = _swig_new_instance_method(_impl.kripke_graph_state_out_end)
    recycle = _swig_new_instance_method(_impl.kripke_graph_state_out_recycle)
    __iter__ = _swig_new_instance_method(_impl.kripke_graph_state_out___iter__)
    __swig_destroy__ = _impl.delete_kripke_graph_state_out

# Register kripke_graph_state_out in _impl:
_impl.kripke_graph_state_out_swigregister(kripke_graph_state_out)
class kripke_graph_all_trans(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, tv):
        _impl.kripke_graph_all_trans_swiginit(self, _impl.new_kripke_graph_all_trans(tv))
    begin = _swig_new_instance_method(_impl.kripke_graph_all_trans_begin)
    end = _swig_new_instance_method(_impl.kripke_graph_all_trans_end)
    __iter__ = _swig_new_instance_method(_impl.kripke_graph_all_trans___iter__)
    __swig_destroy__ = _impl.delete_kripke_graph_all_trans

# Register kripke_graph_all_trans in _impl:
_impl.kripke_graph_all_trans_swigregister(kripke_graph_all_trans)
class kripke_graph_edge_boxed_data(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    data = _swig_new_instance_method(_impl.kripke_graph_edge_boxed_data_data)

    def __init__(self):
        _impl.kripke_graph_edge_boxed_data_swiginit(self, _impl.new_kripke_graph_edge_boxed_data())
    __swig_destroy__ = _impl.delete_kripke_graph_edge_boxed_data

# Register kripke_graph_edge_boxed_data in _impl:
_impl.kripke_graph_edge_boxed_data_swigregister(kripke_graph_edge_boxed_data)
class kripke_graph_edge_storage(kripke_graph_edge_boxed_data):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    dst = property(_impl.kripke_graph_edge_storage_dst_get, _impl.kripke_graph_edge_storage_dst_set)
    next_succ = property(_impl.kripke_graph_edge_storage_next_succ_get, _impl.kripke_graph_edge_storage_next_succ_set)
    src = property(_impl.kripke_graph_edge_storage_src_get, _impl.kripke_graph_edge_storage_src_set)

    def __init__(self):
        _impl.kripke_graph_edge_storage_swiginit(self, _impl.new_kripke_graph_edge_storage())
    __lt__ = _swig_new_instance_method(_impl.kripke_graph_edge_storage___lt__)
    __eq__ = _swig_new_instance_method(_impl.kripke_graph_edge_storage___eq__)
    __swig_destroy__ = _impl.delete_kripke_graph_edge_storage

# Register kripke_graph_edge_storage in _impl:
_impl.kripke_graph_edge_storage_swigregister(kripke_graph_edge_storage)
class kripke_graph_state_boxed_data(kripke_graph_state):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _impl.kripke_graph_state_boxed_data_swiginit(self, _impl.new_kripke_graph_state_boxed_data())
    data = _swig_new_instance_method(_impl.kripke_graph_state_boxed_data_data)
    __swig_destroy__ = _impl.delete_kripke_graph_state_boxed_data

# Register kripke_graph_state_boxed_data in _impl:
_impl.kripke_graph_state_boxed_data_swigregister(kripke_graph_state_boxed_data)
class kripke_graph_state_storage(kripke_graph_state_boxed_data):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    succ = property(_impl.kripke_graph_state_storage_succ_get, _impl.kripke_graph_state_storage_succ_set)
    succ_tail = property(_impl.kripke_graph_state_storage_succ_tail_get, _impl.kripke_graph_state_storage_succ_tail_set)

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

# Register kripke_graph_state_storage in _impl:
_impl.kripke_graph_state_storage_swigregister(kripke_graph_state_storage)
class kripke_graph_state_vector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iterator = _swig_new_instance_method(_impl.kripke_graph_state_vector_iterator)
    def __iter__(self):
        return self.iterator()
    __nonzero__ = _swig_new_instance_method(_impl.kripke_graph_state_vector___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.kripke_graph_state_vector___bool__)
    __len__ = _swig_new_instance_method(_impl.kripke_graph_state_vector___len__)
    __getslice__ = _swig_new_instance_method(_impl.kripke_graph_state_vector___getslice__)
    __setslice__ = _swig_new_instance_method(_impl.kripke_graph_state_vector___setslice__)
    __delslice__ = _swig_new_instance_method(_impl.kripke_graph_state_vector___delslice__)
    __delitem__ = _swig_new_instance_method(_impl.kripke_graph_state_vector___delitem__)
    __getitem__ = _swig_new_instance_method(_impl.kripke_graph_state_vector___getitem__)
    __setitem__ = _swig_new_instance_method(_impl.kripke_graph_state_vector___setitem__)
    pop = _swig_new_instance_method(_impl.kripke_graph_state_vector_pop)
    append = _swig_new_instance_method(_impl.kripke_graph_state_vector_append)
    empty = _swig_new_instance_method(_impl.kripke_graph_state_vector_empty)
    size = _swig_new_instance_method(_impl.kripke_graph_state_vector_size)
    swap = _swig_new_instance_method(_impl.kripke_graph_state_vector_swap)
    begin = _swig_new_instance_method(_impl.kripke_graph_state_vector_begin)
    end = _swig_new_instance_method(_impl.kripke_graph_state_vector_end)
    rbegin = _swig_new_instance_method(_impl.kripke_graph_state_vector_rbegin)
    rend = _swig_new_instance_method(_impl.kripke_graph_state_vector_rend)
    clear = _swig_new_instance_method(_impl.kripke_graph_state_vector_clear)
    get_allocator = _swig_new_instance_method(_impl.kripke_graph_state_vector_get_allocator)
    pop_back = _swig_new_instance_method(_impl.kripke_graph_state_vector_pop_back)
    erase = _swig_new_instance_method(_impl.kripke_graph_state_vector_erase)

    def __init__(self, *args):
        _impl.kripke_graph_state_vector_swiginit(self, _impl.new_kripke_graph_state_vector(*args))
    push_back = _swig_new_instance_method(_impl.kripke_graph_state_vector_push_back)
    front = _swig_new_instance_method(_impl.kripke_graph_state_vector_front)
    back = _swig_new_instance_method(_impl.kripke_graph_state_vector_back)
    assign = _swig_new_instance_method(_impl.kripke_graph_state_vector_assign)
    resize = _swig_new_instance_method(_impl.kripke_graph_state_vector_resize)
    insert = _swig_new_instance_method(_impl.kripke_graph_state_vector_insert)
    reserve = _swig_new_instance_method(_impl.kripke_graph_state_vector_reserve)
    capacity = _swig_new_instance_method(_impl.kripke_graph_state_vector_capacity)
    __swig_destroy__ = _impl.delete_kripke_graph_state_vector

# Register kripke_graph_state_vector in _impl:
_impl.kripke_graph_state_vector_swigregister(kripke_graph_state_vector)
class parse_aut_error_list(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __nonzero__ = _swig_new_instance_method(_impl.parse_aut_error_list___nonzero__)
    __bool__ = _swig_new_instance_method(_impl.parse_aut_error_list___bool__)

    def __init__(self):
        _impl.parse_aut_error_list_swiginit(self, _impl.new_parse_aut_error_list())
    __swig_destroy__ = _impl.delete_parse_aut_error_list

# Register parse_aut_error_list in _impl:
_impl.parse_aut_error_list_swigregister(parse_aut_error_list)
parsed_aut_type_HOA = _impl.parsed_aut_type_HOA
parsed_aut_type_NeverClaim = _impl.parsed_aut_type_NeverClaim
parsed_aut_type_LBTT = _impl.parsed_aut_type_LBTT
parsed_aut_type_DRA = _impl.parsed_aut_type_DRA
parsed_aut_type_DSA = _impl.parsed_aut_type_DSA
parsed_aut_type_PGAME = _impl.parsed_aut_type_PGAME
parsed_aut_type_Unknown = _impl.parsed_aut_type_Unknown
class parsed_aut(object):
    r"""Result of the automaton parser"""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    aut = property(_impl.parsed_aut_aut_get, _impl.parsed_aut_aut_set, doc=r"""
    The parsed automaton.

    May be null if the parser reached the end of the stream or a
    serious error. In the latter case, ``errors`` is non-empty.
    May also be null if the parser is used to parse a Kripke
    structure.
    """)
    ks = property(_impl.parsed_aut_ks_get, _impl.parsed_aut_ks_set, doc=r"""
    The parsed kripke structure.

    Used instead of ``aut`` when the parser is called with option
    want_kripke.
    """)
    aborted = property(_impl.parsed_aut_aborted_get, _impl.parsed_aut_aborted_set, doc=r"""Whether an HOA file was terminated with ``--ABORT``""")
    loc = property(_impl.parsed_aut_loc_get, _impl.parsed_aut_loc_set, doc=r"""Location of the automaton in the stream.""")
    type = property(_impl.parsed_aut_type_get, _impl.parsed_aut_type_set, doc=r"""Format of the automaton.""")
    filename = property(_impl.parsed_aut_filename_get, _impl.parsed_aut_filename_set, doc=r"""Name of the stream (used for displaying syntax errors)""")
    errors = property(_impl.parsed_aut_errors_get, _impl.parsed_aut_errors_set, doc=r"""
    Syntax errors that occurred during parsing.

    Note that the parser does not print any diagnostic.
    Deciding how to output those errors is up to you.
    """)

    def __init__(self, str):
        r"""Construct with *str* as the filename for error display."""
        _impl.parsed_aut_swiginit(self, _impl.new_parsed_aut(str))
    format_errors = _swig_new_instance_method(_impl.parsed_aut_format_errors)
    __swig_destroy__ = _impl.delete_parsed_aut

# Register parsed_aut in _impl:
_impl.parsed_aut_swigregister(parsed_aut)
class automaton_parser_options(object):
    r"""Options controlling the behavior of the automaton stream parser."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ignore_abort = property(_impl.automaton_parser_options_ignore_abort_get, _impl.automaton_parser_options_ignore_abort_set, doc=r"""Skip aborted automata""")
    debug = property(_impl.automaton_parser_options_debug_get, _impl.automaton_parser_options_debug_set, doc=r"""Run the parser in debug mode?""")
    trust_hoa = property(_impl.automaton_parser_options_trust_hoa_get, _impl.automaton_parser_options_trust_hoa_set, doc=r"""Trust properties in HOA files""")
    raise_errors = property(_impl.automaton_parser_options_raise_errors_get, _impl.automaton_parser_options_raise_errors_set, doc=r"""Raise errors as exceptions.""")
    want_kripke = property(_impl.automaton_parser_options_want_kripke_get, _impl.automaton_parser_options_want_kripke_set, doc=r"""Parse as a Kripke structure.""")
    drop_false_edges = property(_impl.automaton_parser_options_drop_false_edges_get, _impl.automaton_parser_options_drop_false_edges_set, doc=r"""Drop edges with false labels.""")

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

# Register automaton_parser_options in _impl:
_impl.automaton_parser_options_swigregister(automaton_parser_options)
class automaton_stream_parser(object):
    r"""
    Parse a stream of automata

    This object should be constructed for a given stream (a file, a
    file descriptor, or a raw buffer), and then its parse() method
    may be called in a loop to parse each automaton in the stream.

    Several input formats are supported, and automatically
    recognized: HOA, LBTT, DSTAR, neverclaim, or PGsolver.  We
    recommend using the HOA format, because it is the most general.

    The specification of the HOA format can be found at
       http://adl.github.io/hoaf/

    The grammar of neverclaim will not accept every possible
    neverclaim output.  It has been tuned to accept the output of
    spin -f, ltl2ba, ltl3ba, and modella.  If you know of some other
    tool that produce Büchi automata in the form of a neverclaim,
    but is not understood by this parser, please report it to
    spot@lrde.epita.fr.

    The parser for HOA recognize a few extensions.  It maps the
    `controlled-AP:` header 'perez.19.hoa' to the
    `synthesis-output` property of Spot.  It also maps
    `spot.highlight.edges:`, `spot.highlight.states:`, and
    `spot.state-player:` to the associated automata properties.

    Parsing PGsolver will label all transitions with bddtrue, and
    will adjust the acceptance condition to Spot's convention of
    solving the game from the point of view of player 1 (i.e.,
    player 1 is the one trying to satisfy the acceptance condition).
    """

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        *Overload 1:*
        Parse from a file.

        :type filename: string
        :param filename: The file to read from.
        :type opts: :py:class:`automaton_parser_options`, optional
        :param opts: Parser options.

        |

        *Overload 2:*
        Parse from an already opened file descriptor.

        The file descriptor will not be closed.

        :type fd: int
        :param fd: The file descriptor to read from.
        :type filename: string
        :param filename: What to display in error messages.
        :type opts: :py:class:`automaton_parser_options`, optional
        :param opts: Parser options.

        |

        *Overload 3:*
        Parse from an already opened file descriptor.

        The file descriptor will not be closed.

        :type fd: int
        :param fd: The file descriptor to read from.
        :type filename: string
        :param filename: What to display in error messages.
        :param opts: Parser options.

        |

        *Overload 4:*
        Parse from a buffer

        :type data: string
        :param data: The buffer to read from.
        :type filename: string
        :param filename: What to display in error messages.
        :type opts: :py:class:`automaton_parser_options`, optional
        :param opts: Parser options.

        |

        *Overload 5:*
        Parse from a buffer

        :type data: string
        :param data: The buffer to read from.
        :type filename: string
        :param filename: What to display in error messages.
        :param opts: Parser options.
        """
        _impl.automaton_stream_parser_swiginit(self, _impl.new_automaton_stream_parser(*args))
    __swig_destroy__ = _impl.delete_automaton_stream_parser
    parse = _swig_new_instance_method(_impl.automaton_stream_parser_parse)

# Register automaton_stream_parser in _impl:
_impl.automaton_stream_parser_swigregister(automaton_stream_parser)
parse_aut = _impl.parse_aut
class ostream(object):
    thisown = 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

# Register ostream in _impl:
_impl.ostream_swigregister(ostream)
class ofstream(ostream):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, fn):
        _impl.ofstream_swiginit(self, _impl.new_ofstream(fn))
    __swig_destroy__ = _impl.delete_ofstream

# Register ofstream in _impl:
_impl.ofstream_swigregister(ofstream)
class ostringstream(ostream):
    thisown = 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())
    str = _swig_new_instance_method(_impl.ostringstream_str)
    __swig_destroy__ = _impl.delete_ostringstream

# Register ostringstream in _impl:
_impl.ostringstream_swigregister(ostringstream)
fnode_instances_check = _impl.fnode_instances_check
ensure_digraph = _impl.ensure_digraph
get_cout = _impl.get_cout
nl_cout = _impl.nl_cout
get_cerr = _impl.get_cerr
nl_cerr = _impl.nl_cerr
print_on = _impl.print_on
unblock_signal = _impl.unblock_signal
states_and = _impl.states_and

