# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.4.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 getattr(globals().get("__spec__"), "parent", None) or __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):
    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):
        _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):
    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):
        _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):
    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.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):
    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):
    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):
        _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)
SPOT_HAS_STRONG_X = _impl.SPOT_HAS_STRONG_X
SPOT_WANT_STRONG_X = _impl.SPOT_WANT_STRONG_X
op_ff = _impl.op_ff
op_tt = _impl.op_tt
op_eword = _impl.op_eword
op_ap = _impl.op_ap
op_Not = _impl.op_Not
op_X = _impl.op_X
op_F = _impl.op_F
op_G = _impl.op_G
op_Closure = _impl.op_Closure
op_NegClosure = _impl.op_NegClosure
op_NegClosureMarked = _impl.op_NegClosureMarked
op_Xor = _impl.op_Xor
op_Implies = _impl.op_Implies
op_Equiv = _impl.op_Equiv
op_U = _impl.op_U
op_R = _impl.op_R
op_W = _impl.op_W
op_M = _impl.op_M
op_EConcat = _impl.op_EConcat
op_EConcatMarked = _impl.op_EConcatMarked
op_UConcat = _impl.op_UConcat
op_Or = _impl.op_Or
op_OrRat = _impl.op_OrRat
op_And = _impl.op_And
op_AndRat = _impl.op_AndRat
op_AndNLM = _impl.op_AndNLM
op_Concat = _impl.op_Concat
op_Fusion = _impl.op_Fusion
op_Star = _impl.op_Star
op_FStar = _impl.op_FStar
op_first_match = _impl.op_first_match
op_strong_X = _impl.op_strong_X
class formula(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        _impl.formula_swiginit(self, _impl.new_formula(*args))
    __swig_destroy__ = _impl.delete_formula
    __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__


    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)
    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)
    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)
    __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")
    __repr__ = _swig_repr
    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)
    __swig_destroy__ = _impl.delete_vectorformula

# Register vectorformula in _impl:
_impl.vectorformula_swigregister(vectorformula)
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 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 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 environment(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
    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):
    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):
    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):
    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)
    input = property(_impl.parsed_formula_input_get, _impl.parsed_formula_input_set)
    errors = property(_impl.parsed_formula_errors_get, _impl.parsed_formula_errors_set)

    def __init__(self, *args):
        _impl.parsed_formula_swiginit(self, _impl.new_parsed_formula(*args))
    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):
    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)
    acc_map = property(_impl.bdd_dict_acc_map_get, _impl.bdd_dict_acc_map_set)
    anon = _impl.bdd_dict_anon
    var = _impl.bdd_dict_var
    acc = _impl.bdd_dict_acc
    bdd_map = property(_impl.bdd_dict_bdd_map_get, _impl.bdd_dict_bdd_map_set)
    has_registered_proposition = _swig_new_instance_method(_impl.bdd_dict_has_registered_proposition)
    varnum = _swig_new_instance_method(_impl.bdd_dict_varnum)
    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):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    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

    def __init__(self):
        _impl.bdd_dict_preorder_swiginit(self, _impl.new_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):
    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):
        _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)
    accepting_sets = _swig_new_instance_method(_impl.acc_cond_accepting_sets)
    format = _swig_new_instance_method(_impl.acc_cond_format)
    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)
    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):
    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):
        _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):
    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)
    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)
    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):
        _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):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, fin, inf):
        _impl.rs_pair_swiginit(self, _impl.new_rs_pair(fin, inf))
    fin = property(_impl.rs_pair_fin_get, _impl.rs_pair_fin_set)
    inf = property(_impl.rs_pair_inf_get, _impl.rs_pair_inf_set)
    __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):
    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.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):
    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):
    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):
    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):
    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):
    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):
    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):
    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):
    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):
    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):
    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):
    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)

    def prop_deterministic(self, *args):

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


        return _impl.twa_prop_deterministic(self, *args)

    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):
    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)
    inherently_weak = property(_impl.twa_prop_set_inherently_weak_get, _impl.twa_prop_set_inherently_weak_set)
    deterministic = property(_impl.twa_prop_set_deterministic_get, _impl.twa_prop_set_deterministic_set)
    improve_det = property(_impl.twa_prop_set_improve_det_get, _impl.twa_prop_set_improve_det_set)
    complete = property(_impl.twa_prop_set_complete_get, _impl.twa_prop_set_complete_set)
    stutter_inv = property(_impl.twa_prop_set_stutter_inv_get, _impl.twa_prop_set_stutter_inv_set)

    def __init__(self, *args):
        _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_equivalent_literals = _impl.collect_equivalent_literals
class realizability_simplifier_base(object):
    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
    global_equiv = _impl.realizability_simplifier_base_global_equiv
    global_equiv_output_only = _impl.realizability_simplifier_base_global_equiv_output_only
    global_equiv_moore = _impl.realizability_simplifier_base_global_equiv_moore

    def __init__(self, *args):
        _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):
    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.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)
class language_containment_checker(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.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):
    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.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)
    synt_impl = property(_impl.tl_simplifier_options_synt_impl_get, _impl.tl_simplifier_options_synt_impl_set)
    event_univ = property(_impl.tl_simplifier_options_event_univ_get, _impl.tl_simplifier_options_event_univ_set)
    containment_checks = property(_impl.tl_simplifier_options_containment_checks_get, _impl.tl_simplifier_options_containment_checks_set)
    containment_checks_stronger = property(_impl.tl_simplifier_options_containment_checks_stronger_get, _impl.tl_simplifier_options_containment_checks_stronger_set)
    nenoform_stop_on_boolean = property(_impl.tl_simplifier_options_nenoform_stop_on_boolean_get, _impl.tl_simplifier_options_nenoform_stop_on_boolean_set)
    reduce_size_strictly = property(_impl.tl_simplifier_options_reduce_size_strictly_get, _impl.tl_simplifier_options_reduce_size_strictly_set)
    boolean_to_isop = property(_impl.tl_simplifier_options_boolean_to_isop_get, _impl.tl_simplifier_options_boolean_to_isop_set)
    favor_event_univ = property(_impl.tl_simplifier_options_favor_event_univ_get, _impl.tl_simplifier_options_favor_event_univ_set)
    keep_top_xor = property(_impl.tl_simplifier_options_keep_top_xor_get, _impl.tl_simplifier_options_keep_top_xor_set)
    containment_max_states = property(_impl.tl_simplifier_options_containment_max_states_get, _impl.tl_simplifier_options_containment_max_states_set)
    containment_max_ops = property(_impl.tl_simplifier_options_containment_max_ops_get, _impl.tl_simplifier_options_containment_max_ops_set)
    __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):
    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.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)
to_delta2 = _impl.to_delta2
class unabbreviator(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.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):
    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):
        _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):
    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):
        _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):
    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):
        _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):
    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):
        _impl.random_sere_swiginit(self, _impl.new_random_sere(ap))
    rb = property(_impl.random_sere_rb_get, _impl.random_sere_rb_set)
    __swig_destroy__ = _impl.delete_random_sere

# Register random_sere in _impl:
_impl.random_sere_swigregister(random_sere)
class random_psl(random_ltl):
    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):
        _impl.random_psl_swiginit(self, _impl.new_random_psl(ap))
    rs = property(_impl.random_psl_rs_get, _impl.random_psl_rs_set)
    __swig_destroy__ = _impl.delete_random_psl

# Register random_psl in _impl:
_impl.random_psl_swigregister(random_psl)
class randltlgenerator(object):
    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

    def __init__(self, *args):
        _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):
    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.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
ltlf_one_step_unsat_rewrite = _impl.ltlf_one_step_unsat_rewrite
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
class taa_tgba(twa):
    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):
    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):
        _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):
    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):
        _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):
    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):
    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):
    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):
        _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):
    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):
        _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):
    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):
        _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):
    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.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):
    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)
    acc = property(_impl.twa_graph_edge_data_acc_get, _impl.twa_graph_edge_data_acc_set)

    def __init__(self, *args):
        _impl.twa_graph_edge_data_swiginit(self, _impl.new_twa_graph_edge_data(*args))
    __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):
    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.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):
    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.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):
    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):
        _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):
    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.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):
    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):
        _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):
    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):
        _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):
    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)
    state_num = property(_impl.nca_st_info_state_num_get, _impl.nca_st_info_state_num_set)
    all_dst = property(_impl.nca_st_info_all_dst_get, _impl.nca_st_info_all_dst_set)

    def __init__(self, clause, st, dst):
        _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
copy = _impl.copy
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
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
dualize = _impl.dualize
class emptiness_check_result(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.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):
    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):
    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):
    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)
    cycle = property(_impl.twa_run_cycle_get, _impl.twa_run_cycle_set)
    aut = property(_impl.twa_run_aut_get, _impl.twa_run_aut_set)
    __swig_destroy__ = _impl.delete_twa_run

    def __init__(self, *args):
        _impl.twa_run_swiginit(self, _impl.new_twa_run(*args))
    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):
    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)
    label = property(_impl.step_label_get, _impl.step_label_set)
    acc = property(_impl.step_acc_get, _impl.step_acc_set)

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

# 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 mtdfa_stats(object):
    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)
    aps = property(_impl.mtdfa_stats_aps_get, _impl.mtdfa_stats_aps_set)
    nodes = property(_impl.mtdfa_stats_nodes_get, _impl.mtdfa_stats_nodes_set)
    terminals = property(_impl.mtdfa_stats_terminals_get, _impl.mtdfa_stats_terminals_set)
    has_true = property(_impl.mtdfa_stats_has_true_get, _impl.mtdfa_stats_has_true_set)
    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)
    edges = property(_impl.mtdfa_stats_edges_get, _impl.mtdfa_stats_edges_set)

    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):
    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):
        _impl.mtdfa_swiginit(self, _impl.new_mtdfa(dict))
    __swig_destroy__ = _impl.delete_mtdfa
    states = property(_impl.mtdfa_states_get, _impl.mtdfa_states_set)
    names = property(_impl.mtdfa_names_get, _impl.mtdfa_names_set)
    aps = property(_impl.mtdfa_aps_get, _impl.mtdfa_aps_set)
    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
bfs_node_backprop = _impl.bfs_node_backprop
dfs_node_backprop = _impl.dfs_node_backprop
dfs_strict_node_backprop = _impl.dfs_strict_node_backprop
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
product_implies = _impl.product_implies
twadfa_to_mtdfa = _impl.twadfa_to_mtdfa
class ltlf_translator(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, dict, simplify_terms=True):
        _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_synthesis_with_dfs = _swig_new_instance_method(_impl.ltlf_translator_ltlf_synthesis_with_dfs)
    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_representative = _swig_new_instance_method(_impl.ltlf_translator_propeq_representative)
    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
MCS_TIE_SCC = _impl.MCS_TIE_SCC
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
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):
    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):
    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.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
scc_info_options_STOP_ON_ACC = _impl.scc_info_options_STOP_ON_ACC
scc_info_options_TRACK_STATES = _impl.scc_info_options_TRACK_STATES
scc_info_options_TRACK_SUCCS = _impl.scc_info_options_TRACK_SUCCS
scc_info_options_TRACK_STATES_IF_FIN_USED = _impl.scc_info_options_TRACK_STATES_IF_FIN_USED
scc_info_options_PROCESS_UNREACHABLE_STATES = _impl.scc_info_options_PROCESS_UNREACHABLE_STATES
scc_info_options_ALL = _impl.scc_info_options_ALL
__and__ = _impl.__and__
__or__ = _impl.__or__
class scc_info(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.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)
    acc = _swig_new_instance_method(_impl.scc_info_acc)
    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)
    used_acc = _swig_new_instance_method(_impl.scc_info_used_acc)
    used_acc_of = _swig_new_instance_method(_impl.scc_info_used_acc_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):
    val = _impl.new_scc_info_with_options(*args)
    return val

class scc_and_mark_filter(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.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_strength = _impl.decompose_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):
    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)
    states = property(_impl.twa_statistics_states_get, _impl.twa_statistics_states_set)

    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):
    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)

    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)
sub_stats_reachable = _impl.sub_stats_reachable
count_all_transitions = _impl.count_all_transitions
class printable_formula(object):
    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):
    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):
    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):
    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):
    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):
    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):
        _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
parity_kind_min = _impl.parity_kind_min
parity_kind_same = _impl.parity_kind_same
parity_kind_any = _impl.parity_kind_any
parity_style_odd = _impl.parity_style_odd
parity_style_even = _impl.parity_style_even
parity_style_same = _impl.parity_style_same
parity_style_any = _impl.parity_style_any
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):
    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)
    parity_odd = property(_impl.reduce_parity_data_parity_odd_get, _impl.reduce_parity_data_parity_odd_set)
    piprime1 = property(_impl.reduce_parity_data_piprime1_get, _impl.reduce_parity_data_piprime1_set)
    piprime2 = property(_impl.reduce_parity_data_piprime2_get, _impl.reduce_parity_data_piprime2_set)

    def __init__(self, aut, layered=False):
        _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):
    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):
        _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):
    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)
    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):
    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.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 = _impl.product
product_or = _impl.product_or
product_xor = _impl.product_xor
product_xnor = _impl.product_xnor
product_susp = _impl.product_susp
product_or_susp = _impl.product_or_susp
split_edges = _impl.split_edges
class edge_separator(object):
    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):
    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)
    s = property(_impl.synthesis_info_s_get, _impl.synthesis_info_s_set)
    minimize_lvl = property(_impl.synthesis_info_minimize_lvl_get, _impl.synthesis_info_minimize_lvl_set)
    sp = property(_impl.synthesis_info_sp_get, _impl.synthesis_info_sp_set)
    bv = property(_impl.synthesis_info_bv_get, _impl.synthesis_info_bv_set)
    verbose_stream = property(_impl.synthesis_info_verbose_stream_get, _impl.synthesis_info_verbose_stream_set)
    opt = property(_impl.synthesis_info_opt_get, _impl.synthesis_info_opt_set)
    dict = property(_impl.synthesis_info_dict_get, _impl.synthesis_info_dict_set)
    __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):
    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)
    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)
    __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):
    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)
    player_map = property(_impl.game_relabeling_map_player_map_get, _impl.game_relabeling_map_player_map_set)

    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):
    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.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):
    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):
        _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 mtdtwa(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, dict):
        _impl.mtdtwa_swiginit(self, _impl.new_mtdtwa(dict))
    __swig_destroy__ = _impl.delete_mtdtwa
    states = property(_impl.mtdtwa_states_get, _impl.mtdtwa_states_set)
    acc = property(_impl.mtdtwa_acc_get, _impl.mtdtwa_acc_set)
    dict_ = property(_impl.mtdtwa_dict__get, _impl.mtdtwa_dict__set)
    terminal_data = property(_impl.mtdtwa_terminal_data_get, _impl.mtdtwa_terminal_data_set)
    num_roots = _swig_new_instance_method(_impl.mtdtwa_num_roots)
    print_dot = _swig_new_instance_method(_impl.mtdtwa_print_dot)

# 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):
    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.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)
    cycle = property(_impl.twa_word_cycle_get, _impl.twa_word_cycle_set)
    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 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):
    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):
        _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):
    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)
    nb_edges_created = property(_impl.to_parity_data_nb_edges_created_get, _impl.to_parity_data_nb_edges_created_set)
    algorithms_used = property(_impl.to_parity_data_algorithms_used_get, _impl.to_parity_data_algorithms_used_set)

    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):
    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)
    use_last = property(_impl.to_parity_options_use_last_get, _impl.to_parity_options_use_last_set)
    use_last_post_process = property(_impl.to_parity_options_use_last_post_process_get, _impl.to_parity_options_use_last_post_process_set)
    force_order = property(_impl.to_parity_options_force_order_get, _impl.to_parity_options_force_order_set)
    partial_degen = property(_impl.to_parity_options_partial_degen_get, _impl.to_parity_options_partial_degen_set)
    acc_clean = property(_impl.to_parity_options_acc_clean_get, _impl.to_parity_options_acc_clean_set)
    parity_equiv = property(_impl.to_parity_options_parity_equiv_get, _impl.to_parity_options_parity_equiv_set)
    car = property(_impl.to_parity_options_car_get, _impl.to_parity_options_car_set)
    tar = property(_impl.to_parity_options_tar_get, _impl.to_parity_options_tar_set)
    iar = property(_impl.to_parity_options_iar_get, _impl.to_parity_options_iar_set)
    lar_dfs = property(_impl.to_parity_options_lar_dfs_get, _impl.to_parity_options_lar_dfs_set)
    bscc = property(_impl.to_parity_options_bscc_get, _impl.to_parity_options_bscc_set)
    parity_prefix = property(_impl.to_parity_options_parity_prefix_get, _impl.to_parity_options_parity_prefix_set)
    parity_prefix_general = property(_impl.to_parity_options_parity_prefix_general_get, _impl.to_parity_options_parity_prefix_general_set)
    generic_emptiness = property(_impl.to_parity_options_generic_emptiness_get, _impl.to_parity_options_generic_emptiness_set)
    rabin_to_buchi = property(_impl.to_parity_options_rabin_to_buchi_get, _impl.to_parity_options_rabin_to_buchi_set)
    buchi_type_to_buchi = property(_impl.to_parity_options_buchi_type_to_buchi_get, _impl.to_parity_options_buchi_type_to_buchi_set)
    parity_type_to_parity = property(_impl.to_parity_options_parity_type_to_parity_get, _impl.to_parity_options_parity_type_to_parity_set)
    reduce_col_deg = property(_impl.to_parity_options_reduce_col_deg_get, _impl.to_parity_options_reduce_col_deg_set)
    propagate_col = property(_impl.to_parity_options_propagate_col_get, _impl.to_parity_options_propagate_col_set)
    use_generalized_rabin = property(_impl.to_parity_options_use_generalized_rabin_get, _impl.to_parity_options_use_generalized_rabin_set)
    pretty_print = property(_impl.to_parity_options_pretty_print_get, _impl.to_parity_options_pretty_print_set)
    datas = property(_impl.to_parity_options_datas_get, _impl.to_parity_options_datas_set)

    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
iar = _impl.iar
iar_maybe = _impl.iar_maybe
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
zielonka_tree_options_CHECK_RABIN = _impl.zielonka_tree_options_CHECK_RABIN
zielonka_tree_options_CHECK_STREETT = _impl.zielonka_tree_options_CHECK_STREETT
zielonka_tree_options_CHECK_PARITY = _impl.zielonka_tree_options_CHECK_PARITY
zielonka_tree_options_ABORT_WRONG_SHAPE = _impl.zielonka_tree_options_ABORT_WRONG_SHAPE
zielonka_tree_options_MERGE_SUBTREES = _impl.zielonka_tree_options_MERGE_SUBTREES
zielonka_tree_options_NO_EMPTY_LAYER = _impl.zielonka_tree_options_NO_EMPTY_LAYER
class zielonka_tree(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.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)
    __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
acd_options_CHECK_RABIN = _impl.acd_options_CHECK_RABIN
acd_options_CHECK_STREETT = _impl.acd_options_CHECK_STREETT
acd_options_CHECK_PARITY = _impl.acd_options_CHECK_PARITY
acd_options_ABORT_WRONG_SHAPE = _impl.acd_options_ABORT_WRONG_SHAPE
acd_options_ORDER_HEURISTIC = _impl.acd_options_ORDER_HEURISTIC
class acd(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.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
dtwa_complement = _impl.dtwa_complement
complement_semidet = _impl.complement_semidet
complement = _impl.complement
class fair_kripke_succ_iterator(twa_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_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):
    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):
    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):
    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):
    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.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):
    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):
        _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):
    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)
    ks = property(_impl.parsed_aut_ks_get, _impl.parsed_aut_ks_set)
    aborted = property(_impl.parsed_aut_aborted_get, _impl.parsed_aut_aborted_set)
    loc = property(_impl.parsed_aut_loc_get, _impl.parsed_aut_loc_set)
    type = property(_impl.parsed_aut_type_get, _impl.parsed_aut_type_set)
    filename = property(_impl.parsed_aut_filename_get, _impl.parsed_aut_filename_set)
    errors = property(_impl.parsed_aut_errors_get, _impl.parsed_aut_errors_set)

    def __init__(self, str):
        _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):
    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)
    debug = property(_impl.automaton_parser_options_debug_get, _impl.automaton_parser_options_debug_set)
    trust_hoa = property(_impl.automaton_parser_options_trust_hoa_get, _impl.automaton_parser_options_trust_hoa_set)
    raise_errors = property(_impl.automaton_parser_options_raise_errors_get, _impl.automaton_parser_options_raise_errors_set)
    want_kripke = property(_impl.automaton_parser_options_want_kripke_get, _impl.automaton_parser_options_want_kripke_set)
    drop_false_edges = property(_impl.automaton_parser_options_drop_false_edges_get, _impl.automaton_parser_options_drop_false_edges_set)

    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):
    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.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 ta(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_ta
    get_initial_states_set = _swig_new_instance_method(_impl.ta_get_initial_states_set)
    get_artificial_initial_state = _swig_new_instance_method(_impl.ta_get_artificial_initial_state)
    succ_iter = _swig_new_instance_method(_impl.ta_succ_iter)
    get_dict = _swig_new_instance_method(_impl.ta_get_dict)
    format_state = _swig_new_instance_method(_impl.ta_format_state)
    is_accepting_state = _swig_new_instance_method(_impl.ta_is_accepting_state)
    is_livelock_accepting_state = _swig_new_instance_method(_impl.ta_is_livelock_accepting_state)
    is_initial_state = _swig_new_instance_method(_impl.ta_is_initial_state)
    get_state_condition = _swig_new_instance_method(_impl.ta_get_state_condition)
    free_state = _swig_new_instance_method(_impl.ta_free_state)
    acc = _swig_new_instance_method(_impl.ta_acc)

# Register ta in _impl:
_impl.ta_swigregister(ta)
class ta_succ_iterator(twa_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_ta_succ_iterator

# Register ta_succ_iterator in _impl:
_impl.ta_succ_iterator_swigregister(ta_succ_iterator)
class tgta(twa):
    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_tgta
    succ_iter_by_changeset = _swig_new_instance_method(_impl.tgta_succ_iter_by_changeset)

# Register tgta in _impl:
_impl.tgta_swigregister(tgta)
class ta_explicit(ta):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, tgba, n_acc, artificial_initial_state=None):
        _impl.ta_explicit_swiginit(self, _impl.new_ta_explicit(tgba, n_acc, artificial_initial_state))
    get_tgba = _swig_new_instance_method(_impl.ta_explicit_get_tgba)
    add_state = _swig_new_instance_method(_impl.ta_explicit_add_state)
    add_to_initial_states_set = _swig_new_instance_method(_impl.ta_explicit_add_to_initial_states_set)
    create_transition = _swig_new_instance_method(_impl.ta_explicit_create_transition)
    delete_stuttering_transitions = _swig_new_instance_method(_impl.ta_explicit_delete_stuttering_transitions)
    __swig_destroy__ = _impl.delete_ta_explicit
    succ_iter = _swig_new_instance_method(_impl.ta_explicit_succ_iter)
    get_dict = _swig_new_instance_method(_impl.ta_explicit_get_dict)
    get_artificial_initial_state = _swig_new_instance_method(_impl.ta_explicit_get_artificial_initial_state)
    set_artificial_initial_state = _swig_new_instance_method(_impl.ta_explicit_set_artificial_initial_state)
    delete_stuttering_and_hole_successors = _swig_new_instance_method(_impl.ta_explicit_delete_stuttering_and_hole_successors)
    get_states_set = _swig_new_instance_method(_impl.ta_explicit_get_states_set)

# Register ta_explicit in _impl:
_impl.ta_explicit_swigregister(ta_explicit)
class state_ta_explicit(state):
    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_state_ta_explicit

# Register state_ta_explicit in _impl:
_impl.state_ta_explicit_swigregister(state_ta_explicit)
class ta_explicit_succ_iterator(ta_succ_iterator):
    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.ta_explicit_succ_iterator_swiginit(self, _impl.new_ta_explicit_succ_iterator(*args))
    __swig_destroy__ = _impl.delete_ta_explicit_succ_iterator

# Register ta_explicit_succ_iterator in _impl:
_impl.ta_explicit_succ_iterator_swigregister(ta_explicit_succ_iterator)
make_ta_explicit = _impl.make_ta_explicit
class tgta_explicit(tgta):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, tgba, n_acc, artificial_initial_state):
        _impl.tgta_explicit_swiginit(self, _impl.new_tgta_explicit(tgba, n_acc, artificial_initial_state))
    get_init_state = _swig_new_instance_method(_impl.tgta_explicit_get_init_state)
    get_ta = _swig_new_instance_method(_impl.tgta_explicit_get_ta)
    __swig_destroy__ = _impl.delete_tgta_explicit

# Register tgta_explicit in _impl:
_impl.tgta_explicit_swigregister(tgta_explicit)
make_tgta_explicit = _impl.make_tgta_explicit
tgba_to_ta = _impl.tgba_to_ta
tgba_to_tgta = _impl.tgba_to_tgta
print_dot = _impl.print_dot
class ta_statistics(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    edges = property(_impl.ta_statistics_edges_get, _impl.ta_statistics_edges_set)
    states = property(_impl.ta_statistics_states_get, _impl.ta_statistics_states_set)
    acceptance_states = property(_impl.ta_statistics_acceptance_states_get, _impl.ta_statistics_acceptance_states_set)
    dump = _swig_new_instance_method(_impl.ta_statistics_dump)

    def __init__(self):
        _impl.ta_statistics_swiginit(self, _impl.new_ta_statistics())
    __swig_destroy__ = _impl.delete_ta_statistics

# Register ta_statistics in _impl:
_impl.ta_statistics_swigregister(ta_statistics)
stats_reachable = _impl.stats_reachable
minimize_ta = _impl.minimize_ta
minimize_tgta = _impl.minimize_tgta
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

