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





from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_dd')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_dd')
    _dd = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_dd', [dirname(__file__)])
        except ImportError:
            import _dd
            return _dd
        if fp is not None:
            try:
                _mod = imp.load_module('_dd', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _dd = swig_import_helper()
    del swig_import_helper
else:
    import _dd
del _swig_python_version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


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


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0

CUDD_REORDER_SAME = _dd.CUDD_REORDER_SAME
CUDD_REORDER_NONE = _dd.CUDD_REORDER_NONE
CUDD_REORDER_RANDOM = _dd.CUDD_REORDER_RANDOM
CUDD_REORDER_RANDOM_PIVOT = _dd.CUDD_REORDER_RANDOM_PIVOT
CUDD_REORDER_SIFT = _dd.CUDD_REORDER_SIFT
CUDD_REORDER_SIFT_CONVERGE = _dd.CUDD_REORDER_SIFT_CONVERGE
CUDD_REORDER_SYMM_SIFT = _dd.CUDD_REORDER_SYMM_SIFT
CUDD_REORDER_SYMM_SIFT_CONV = _dd.CUDD_REORDER_SYMM_SIFT_CONV
CUDD_REORDER_WINDOW2 = _dd.CUDD_REORDER_WINDOW2
CUDD_REORDER_WINDOW3 = _dd.CUDD_REORDER_WINDOW3
CUDD_REORDER_WINDOW4 = _dd.CUDD_REORDER_WINDOW4
CUDD_REORDER_WINDOW2_CONV = _dd.CUDD_REORDER_WINDOW2_CONV
CUDD_REORDER_WINDOW3_CONV = _dd.CUDD_REORDER_WINDOW3_CONV
CUDD_REORDER_WINDOW4_CONV = _dd.CUDD_REORDER_WINDOW4_CONV
CUDD_REORDER_GROUP_SIFT = _dd.CUDD_REORDER_GROUP_SIFT
CUDD_REORDER_GROUP_SIFT_CONV = _dd.CUDD_REORDER_GROUP_SIFT_CONV
CUDD_REORDER_ANNEALING = _dd.CUDD_REORDER_ANNEALING
CUDD_REORDER_GENETIC = _dd.CUDD_REORDER_GENETIC
CUDD_REORDER_LINEAR = _dd.CUDD_REORDER_LINEAR
CUDD_REORDER_LINEAR_CONVERGE = _dd.CUDD_REORDER_LINEAR_CONVERGE
CUDD_REORDER_LAZY_SIFT = _dd.CUDD_REORDER_LAZY_SIFT
CUDD_REORDER_EXACT = _dd.CUDD_REORDER_EXACT

def reordering_status(dd: 'DdManager *') -> "dd_reorderingtype *":
    """reordering_status(DdManager * dd) -> int"""
    return _dd.reordering_status(dd)

def bdd_equal(a: 'bdd_ptr', b: 'bdd_ptr') -> "int":
    """bdd_equal(bdd_ptr a, bdd_ptr b) -> int"""
    return _dd.bdd_equal(a, b)
class reordering_status_result(_object):
    """Proxy of C reordering_status_result struct."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, reordering_status_result, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, reordering_status_result, name)
    __repr__ = _swig_repr
    __swig_setmethods__["status"] = _dd.reordering_status_result_status_set
    __swig_getmethods__["status"] = _dd.reordering_status_result_status_get
    if _newclass:
        status = _swig_property(_dd.reordering_status_result_status_get, _dd.reordering_status_result_status_set)
    __swig_setmethods__["method"] = _dd.reordering_status_result_method_set
    __swig_getmethods__["method"] = _dd.reordering_status_result_method_get
    if _newclass:
        method = _swig_property(_dd.reordering_status_result_method_get, _dd.reordering_status_result_method_set)

    def __init__(self):
        """__init__(reordering_status_result self) -> reordering_status_result"""
        this = _dd.new_reordering_status_result()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _dd.delete_reordering_status_result
    __del__ = lambda self: None
reordering_status_result_swigregister = _dd.reordering_status_result_swigregister
reordering_status_result_swigregister(reordering_status_result)


def wrap_dd_reordering_status(dd: 'DdManager *') -> "reordering_status_result":
    """wrap_dd_reordering_status(DdManager * dd) -> reordering_status_result"""
    return _dd.wrap_dd_reordering_status(dd)
PRIuPTR = _dd.PRIuPTR
PRIdPTR = _dd.PRIdPTR
LLU = _dd.LLU
LLO = _dd.LLO
LLX = _dd.LLX
false = _dd.false
true = _dd.true
OUTCOME_GENERIC_ERROR = _dd.OUTCOME_GENERIC_ERROR
OUTCOME_PARSER_ERROR = _dd.OUTCOME_PARSER_ERROR
OUTCOME_SYNTAX_ERROR = _dd.OUTCOME_SYNTAX_ERROR
OUTCOME_FILE_ERROR = _dd.OUTCOME_FILE_ERROR
OUTCOME_SUCCESS_REQUIRED_HELP = _dd.OUTCOME_SUCCESS_REQUIRED_HELP
OUTCOME_SUCCESS = _dd.OUTCOME_SUCCESS
DEFAULT_MINSIZE = _dd.DEFAULT_MINSIZE

def init_dd_package() -> "DdManager *":
    """init_dd_package() -> DdManager *"""
    return _dd.init_dd_package()

def quit_dd_package(arg1: 'DdManager *') -> "void":
    """quit_dd_package(DdManager * arg1)"""
    return _dd.quit_dd_package(arg1)

def add_true(arg1: 'DdManager *') -> "add_ptr":
    """add_true(DdManager * arg1) -> add_ptr"""
    return _dd.add_true(arg1)

def add_then(arg1: 'DdManager *', arg2: 'add_ptr') -> "add_ptr":
    """add_then(DdManager * arg1, add_ptr arg2) -> add_ptr"""
    return _dd.add_then(arg1, arg2)

def add_else(arg1: 'DdManager *', arg2: 'add_ptr') -> "add_ptr":
    """add_else(DdManager * arg1, add_ptr arg2) -> add_ptr"""
    return _dd.add_else(arg1, arg2)

def add_index(arg1: 'DdManager *', arg2: 'add_ptr') -> "int":
    """add_index(DdManager * arg1, add_ptr arg2) -> int"""
    return _dd.add_index(arg1, arg2)

def add_false(arg1: 'DdManager *') -> "add_ptr":
    """add_false(DdManager * arg1) -> add_ptr"""
    return _dd.add_false(arg1)

def add_is_true(arg1: 'DdManager *', arg2: 'add_ptr') -> "int":
    """add_is_true(DdManager * arg1, add_ptr arg2) -> int"""
    return _dd.add_is_true(arg1, arg2)

def add_is_false(arg1: 'DdManager *', arg2: 'add_ptr') -> "int":
    """add_is_false(DdManager * arg1, add_ptr arg2) -> int"""
    return _dd.add_is_false(arg1, arg2)

def add_one(arg1: 'DdManager *') -> "add_ptr":
    """add_one(DdManager * arg1) -> add_ptr"""
    return _dd.add_one(arg1)

def add_zero(arg1: 'DdManager *') -> "add_ptr":
    """add_zero(DdManager * arg1) -> add_ptr"""
    return _dd.add_zero(arg1)

def add_is_one(arg1: 'DdManager *', arg2: 'add_ptr') -> "int":
    """add_is_one(DdManager * arg1, add_ptr arg2) -> int"""
    return _dd.add_is_one(arg1, arg2)

def add_is_zero(arg1: 'DdManager *', arg2: 'add_ptr') -> "int":
    """add_is_zero(DdManager * arg1, add_ptr arg2) -> int"""
    return _dd.add_is_zero(arg1, arg2)

def add_ref(arg1: 'add_ptr') -> "void":
    """add_ref(add_ptr arg1)"""
    return _dd.add_ref(arg1)

def add_deref(arg1: 'add_ptr') -> "void":
    """add_deref(add_ptr arg1)"""
    return _dd.add_deref(arg1)

def add_dup(arg1: 'add_ptr') -> "add_ptr":
    """add_dup(add_ptr arg1) -> add_ptr"""
    return _dd.add_dup(arg1)

def add_free(arg1: 'DdManager *', arg2: 'add_ptr') -> "void":
    """add_free(DdManager * arg1, add_ptr arg2)"""
    return _dd.add_free(arg1, arg2)

def add_new_var_with_index(arg1: 'DdManager *', arg2: 'int') -> "add_ptr":
    """add_new_var_with_index(DdManager * arg1, int arg2) -> add_ptr"""
    return _dd.add_new_var_with_index(arg1, arg2)

def add_build(arg1: 'DdManager *', arg2: 'int', arg3: 'add_ptr', arg4: 'add_ptr') -> "add_ptr":
    """add_build(DdManager * arg1, int arg2, add_ptr arg3, add_ptr arg4) -> add_ptr"""
    return _dd.add_build(arg1, arg2, arg3, arg4)

def add_new_var_at_level(arg1: 'DdManager *', arg2: 'int') -> "add_ptr":
    """add_new_var_at_level(DdManager * arg1, int arg2) -> add_ptr"""
    return _dd.add_new_var_at_level(arg1, arg2)

def add_isleaf(arg1: 'add_ptr') -> "int":
    """add_isleaf(add_ptr arg1) -> int"""
    return _dd.add_isleaf(arg1)

def bdd_isleaf(arg1: 'add_ptr') -> "int":
    """bdd_isleaf(add_ptr arg1) -> int"""
    return _dd.bdd_isleaf(arg1)

def add_leaf(arg1: 'DdManager *', arg2: 'node_ptr') -> "add_ptr":
    """add_leaf(DdManager * arg1, node_ptr arg2) -> add_ptr"""
    return _dd.add_leaf(arg1, arg2)

def add_get_leaf(arg1: 'DdManager *', arg2: 'add_ptr') -> "node_ptr":
    """add_get_leaf(DdManager * arg1, add_ptr arg2) -> node_ptr"""
    return _dd.add_get_leaf(arg1, arg2)

def add_to_bdd(arg1: 'DdManager *', arg2: 'add_ptr') -> "bdd_ptr":
    """add_to_bdd(DdManager * arg1, add_ptr arg2) -> bdd_ptr"""
    return _dd.add_to_bdd(arg1, arg2)

def add_to_bdd_strict_threshold(arg1: 'DdManager *', arg2: 'add_ptr', arg3: 'int') -> "bdd_ptr":
    """add_to_bdd_strict_threshold(DdManager * arg1, add_ptr arg2, int arg3) -> bdd_ptr"""
    return _dd.add_to_bdd_strict_threshold(arg1, arg2, arg3)

def bdd_to_add(arg1: 'DdManager *', arg2: 'bdd_ptr') -> "add_ptr":
    """bdd_to_add(DdManager * arg1, bdd_ptr arg2) -> add_ptr"""
    return _dd.bdd_to_add(arg1, arg2)

def bdd_to_01_add(arg1: 'DdManager *', arg2: 'bdd_ptr') -> "add_ptr":
    """bdd_to_01_add(DdManager * arg1, bdd_ptr arg2) -> add_ptr"""
    return _dd.bdd_to_01_add(arg1, arg2)

def add_and(arg1: 'DdManager *', arg2: 'add_ptr', arg3: 'add_ptr') -> "add_ptr":
    """add_and(DdManager * arg1, add_ptr arg2, add_ptr arg3) -> add_ptr"""
    return _dd.add_and(arg1, arg2, arg3)

def add_and_accumulate(arg1: 'DdManager *', arg2: 'add_ptr *', arg3: 'add_ptr') -> "void":
    """add_and_accumulate(DdManager * arg1, add_ptr * arg2, add_ptr arg3)"""
    return _dd.add_and_accumulate(arg1, arg2, arg3)

def add_or(arg1: 'DdManager *', arg2: 'add_ptr', arg3: 'add_ptr') -> "add_ptr":
    """add_or(DdManager * arg1, add_ptr arg2, add_ptr arg3) -> add_ptr"""
    return _dd.add_or(arg1, arg2, arg3)

def add_or_accumulate(arg1: 'DdManager *', arg2: 'add_ptr *', arg3: 'add_ptr') -> "void":
    """add_or_accumulate(DdManager * arg1, add_ptr * arg2, add_ptr arg3)"""
    return _dd.add_or_accumulate(arg1, arg2, arg3)

def add_not(arg1: 'DdManager *', arg2: 'add_ptr') -> "add_ptr":
    """add_not(DdManager * arg1, add_ptr arg2) -> add_ptr"""
    return _dd.add_not(arg1, arg2)

def add_implies(arg1: 'DdManager *', arg2: 'add_ptr', arg3: 'add_ptr') -> "add_ptr":
    """add_implies(DdManager * arg1, add_ptr arg2, add_ptr arg3) -> add_ptr"""
    return _dd.add_implies(arg1, arg2, arg3)

def add_iff(arg1: 'DdManager *', arg2: 'add_ptr', arg3: 'add_ptr') -> "add_ptr":
    """add_iff(DdManager * arg1, add_ptr arg2, add_ptr arg3) -> add_ptr"""
    return _dd.add_iff(arg1, arg2, arg3)

def add_xor(arg1: 'DdManager *', arg2: 'add_ptr', arg3: 'add_ptr') -> "add_ptr":
    """add_xor(DdManager * arg1, add_ptr arg2, add_ptr arg3) -> add_ptr"""
    return _dd.add_xor(arg1, arg2, arg3)

def add_xnor(arg1: 'DdManager *', arg2: 'add_ptr', arg3: 'add_ptr') -> "add_ptr":
    """add_xnor(DdManager * arg1, add_ptr arg2, add_ptr arg3) -> add_ptr"""
    return _dd.add_xnor(arg1, arg2, arg3)

def add_apply(arg1: 'DdManager *', arg2: 'NPFNN', arg3: 'add_ptr', arg4: 'add_ptr') -> "add_ptr":
    """add_apply(DdManager * arg1, NPFNN arg2, add_ptr arg3, add_ptr arg4) -> add_ptr"""
    return _dd.add_apply(arg1, arg2, arg3, arg4)

def add_monadic_apply(arg1: 'DdManager *', arg2: 'NPFNN', arg3: 'add_ptr') -> "add_ptr":
    """add_monadic_apply(DdManager * arg1, NPFNN arg2, add_ptr arg3) -> add_ptr"""
    return _dd.add_monadic_apply(arg1, arg2, arg3)

def add_exist_abstract(dd: 'DdManager *', a: 'add_ptr', b: 'bdd_ptr') -> "add_ptr":
    """add_exist_abstract(DdManager * dd, add_ptr a, bdd_ptr b) -> add_ptr"""
    return _dd.add_exist_abstract(dd, a, b)

def add_ifthenelse(arg1: 'DdManager *', arg2: 'add_ptr', arg3: 'add_ptr', arg4: 'add_ptr') -> "add_ptr":
    """add_ifthenelse(DdManager * arg1, add_ptr arg2, add_ptr arg3, add_ptr arg4) -> add_ptr"""
    return _dd.add_ifthenelse(arg1, arg2, arg3, arg4)

def add_cube_diff(arg1: 'DdManager *', arg2: 'add_ptr', arg3: 'add_ptr') -> "add_ptr":
    """add_cube_diff(DdManager * arg1, add_ptr arg2, add_ptr arg3) -> add_ptr"""
    return _dd.add_cube_diff(arg1, arg2, arg3)

def add_simplify_assuming(arg1: 'DdManager *', arg2: 'add_ptr', arg3: 'add_ptr') -> "add_ptr":
    """add_simplify_assuming(DdManager * arg1, add_ptr arg2, add_ptr arg3) -> add_ptr"""
    return _dd.add_simplify_assuming(arg1, arg2, arg3)

def add_permute(arg1: 'DdManager *', arg2: 'add_ptr', arg3: 'int *') -> "add_ptr":
    """add_permute(DdManager * arg1, add_ptr arg2, int * arg3) -> add_ptr"""
    return _dd.add_permute(arg1, arg2, arg3)

def add_support(arg1: 'DdManager *', arg2: 'add_ptr') -> "add_ptr":
    """add_support(DdManager * arg1, add_ptr arg2) -> add_ptr"""
    return _dd.add_support(arg1, arg2)

def add_walkleaves(arg1: 'VPFCVT', arg2: 'add_ptr') -> "void":
    """add_walkleaves(VPFCVT arg1, add_ptr arg2)"""
    return _dd.add_walkleaves(arg1, arg2)

def add_size(arg1: 'DdManager *', arg2: 'add_ptr') -> "int":
    """add_size(DdManager * arg1, add_ptr arg2) -> int"""
    return _dd.add_size(arg1, arg2)

def add_count_minterm(arg1: 'DdManager *', arg2: 'add_ptr', arg3: 'int') -> "double":
    """add_count_minterm(DdManager * arg1, add_ptr arg2, int arg3) -> double"""
    return _dd.add_count_minterm(arg1, arg2, arg3)

def get_dd_nodes_allocated(arg1: 'DdManager *') -> "int":
    """get_dd_nodes_allocated(DdManager * arg1) -> int"""
    return _dd.get_dd_nodes_allocated(arg1)

def add_value(arg1: 'DdManager *', arg2: 'add_ptr') -> "node_ptr":
    """add_value(DdManager * arg1, add_ptr arg2) -> node_ptr"""
    return _dd.add_value(arg1, arg2)

def add_if_then(arg1: 'DdManager *', arg2: 'add_ptr', arg3: 'add_ptr') -> "add_ptr":
    """add_if_then(DdManager * arg1, add_ptr arg2, add_ptr arg3) -> add_ptr"""
    return _dd.add_if_then(arg1, arg2, arg3)

def map_dd(arg1: 'DdManager *', arg2: 'NPFDD', arg3: 'node_ptr') -> "node_ptr":
    """map_dd(DdManager * arg1, NPFDD arg2, node_ptr arg3) -> node_ptr"""
    return _dd.map_dd(arg1, arg2, arg3)

def walk_dd(arg1: 'DdManager *', arg2: 'VPFDD', arg3: 'node_ptr') -> "void":
    """walk_dd(DdManager * arg1, VPFDD arg2, node_ptr arg3)"""
    return _dd.walk_dd(arg1, arg2, arg3)

def dd_new_var_block(arg1: 'DdManager *', arg2: 'int', arg3: 'int') -> "dd_block *":
    """dd_new_var_block(DdManager * arg1, int arg2, int arg3) -> dd_block *"""
    return _dd.dd_new_var_block(arg1, arg2, arg3)

def dd_free_var_block(arg1: 'DdManager *', arg2: 'dd_block *') -> "int":
    """dd_free_var_block(DdManager * arg1, dd_block * arg2) -> int"""
    return _dd.dd_free_var_block(arg1, arg2)

def dd_get_index_at_level(arg1: 'DdManager *', arg2: 'int') -> "int":
    """dd_get_index_at_level(DdManager * arg1, int arg2) -> int"""
    return _dd.dd_get_index_at_level(arg1, arg2)

def dd_get_level_at_index(arg1: 'DdManager *', arg2: 'int') -> "int":
    """dd_get_level_at_index(DdManager * arg1, int arg2) -> int"""
    return _dd.dd_get_level_at_index(arg1, arg2)

def dd_get_size(arg1: 'DdManager *') -> "int":
    """dd_get_size(DdManager * arg1) -> int"""
    return _dd.dd_get_size(arg1)

def dd_set_order(arg1: 'DdManager *', permutation: 'int *') -> "int":
    """dd_set_order(DdManager * arg1, int * permutation) -> int"""
    return _dd.dd_set_order(arg1, permutation)

def dd_autodyn_enable(arg1: 'DdManager *', arg2: 'dd_reorderingtype') -> "void":
    """dd_autodyn_enable(DdManager * arg1, dd_reorderingtype arg2)"""
    return _dd.dd_autodyn_enable(arg1, arg2)

def dd_autodyn_disable(arg1: 'DdManager *') -> "void":
    """dd_autodyn_disable(DdManager * arg1)"""
    return _dd.dd_autodyn_disable(arg1)

def dd_reordering_status(arg1: 'DdManager *', arg2: 'dd_reorderingtype *') -> "int":
    """dd_reordering_status(DdManager * arg1, dd_reorderingtype * arg2) -> int"""
    return _dd.dd_reordering_status(arg1, arg2)

def dd_reorder(arg1: 'DdManager *', arg2: 'int', arg3: 'int') -> "int":
    """dd_reorder(DdManager * arg1, int arg2, int arg3) -> int"""
    return _dd.dd_reorder(arg1, arg2, arg3)

def dd_get_reorderings(arg1: 'DdManager *') -> "int":
    """dd_get_reorderings(DdManager * arg1) -> int"""
    return _dd.dd_get_reorderings(arg1)

def dd_get_ordering_method(arg1: 'DdManager *') -> "dd_reorderingtype":
    """dd_get_ordering_method(DdManager * arg1) -> dd_reorderingtype"""
    return _dd.dd_get_ordering_method(arg1)

def StringConvertToDynOrderType(string: 'char *') -> "int":
    """StringConvertToDynOrderType(char * string) -> int"""
    return _dd.StringConvertToDynOrderType(string)

def DynOrderTypeConvertToString(method: 'int') -> "char *":
    """DynOrderTypeConvertToString(int method) -> char *"""
    return _dd.DynOrderTypeConvertToString(method)

def dd_checkzeroref(arg1: 'DdManager *') -> "int":
    """dd_checkzeroref(DdManager * arg1) -> int"""
    return _dd.dd_checkzeroref(arg1)

def bdd_ref(arg1: 'bdd_ptr') -> "void":
    """bdd_ref(bdd_ptr arg1)"""
    return _dd.bdd_ref(arg1)

def bdd_deref(arg1: 'bdd_ptr') -> "void":
    """bdd_deref(bdd_ptr arg1)"""
    return _dd.bdd_deref(arg1)

def bdd_dup(arg1: 'bdd_ptr') -> "bdd_ptr":
    """bdd_dup(bdd_ptr arg1) -> bdd_ptr"""
    return _dd.bdd_dup(arg1)

def bdd_true(arg1: 'DdManager *') -> "bdd_ptr":
    """bdd_true(DdManager * arg1) -> bdd_ptr"""
    return _dd.bdd_true(arg1)

def bdd_false(arg1: 'DdManager *') -> "bdd_ptr":
    """bdd_false(DdManager * arg1) -> bdd_ptr"""
    return _dd.bdd_false(arg1)

def bdd_is_true(arg1: 'DdManager *', arg2: 'bdd_ptr') -> "int":
    """bdd_is_true(DdManager * arg1, bdd_ptr arg2) -> int"""
    return _dd.bdd_is_true(arg1, arg2)

def bdd_is_false(arg1: 'DdManager *', arg2: 'bdd_ptr') -> "int":
    """bdd_is_false(DdManager * arg1, bdd_ptr arg2) -> int"""
    return _dd.bdd_is_false(arg1, arg2)

def bdd_isnot_true(arg1: 'DdManager *', arg2: 'bdd_ptr') -> "int":
    """bdd_isnot_true(DdManager * arg1, bdd_ptr arg2) -> int"""
    return _dd.bdd_isnot_true(arg1, arg2)

def bdd_isnot_false(arg1: 'DdManager *', arg2: 'bdd_ptr') -> "int":
    """bdd_isnot_false(DdManager * arg1, bdd_ptr arg2) -> int"""
    return _dd.bdd_isnot_false(arg1, arg2)

def bdd_free(arg1: 'DdManager *', arg2: 'bdd_ptr') -> "void":
    """bdd_free(DdManager * arg1, bdd_ptr arg2)"""
    return _dd.bdd_free(arg1, arg2)

def bdd_not(arg1: 'DdManager *', arg2: 'bdd_ptr') -> "bdd_ptr":
    """bdd_not(DdManager * arg1, bdd_ptr arg2) -> bdd_ptr"""
    return _dd.bdd_not(arg1, arg2)

def bdd_and(arg1: 'DdManager *', arg2: 'bdd_ptr', arg3: 'bdd_ptr') -> "bdd_ptr":
    """bdd_and(DdManager * arg1, bdd_ptr arg2, bdd_ptr arg3) -> bdd_ptr"""
    return _dd.bdd_and(arg1, arg2, arg3)

def bdd_and_accumulate(arg1: 'DdManager *', arg2: 'bdd_ptr *', arg3: 'bdd_ptr') -> "void":
    """bdd_and_accumulate(DdManager * arg1, bdd_ptr * arg2, bdd_ptr arg3)"""
    return _dd.bdd_and_accumulate(arg1, arg2, arg3)

def bdd_or(arg1: 'DdManager *', arg2: 'bdd_ptr', arg3: 'bdd_ptr') -> "bdd_ptr":
    """bdd_or(DdManager * arg1, bdd_ptr arg2, bdd_ptr arg3) -> bdd_ptr"""
    return _dd.bdd_or(arg1, arg2, arg3)

def bdd_or_accumulate(arg1: 'DdManager *', arg2: 'bdd_ptr *', arg3: 'bdd_ptr') -> "void":
    """bdd_or_accumulate(DdManager * arg1, bdd_ptr * arg2, bdd_ptr arg3)"""
    return _dd.bdd_or_accumulate(arg1, arg2, arg3)

def bdd_xor(arg1: 'DdManager *', arg2: 'bdd_ptr', arg3: 'bdd_ptr') -> "bdd_ptr":
    """bdd_xor(DdManager * arg1, bdd_ptr arg2, bdd_ptr arg3) -> bdd_ptr"""
    return _dd.bdd_xor(arg1, arg2, arg3)

def bdd_iff(arg1: 'DdManager *', arg2: 'bdd_ptr', arg3: 'bdd_ptr') -> "bdd_ptr":
    """bdd_iff(DdManager * arg1, bdd_ptr arg2, bdd_ptr arg3) -> bdd_ptr"""
    return _dd.bdd_iff(arg1, arg2, arg3)

def bdd_imply(arg1: 'DdManager *', arg2: 'bdd_ptr', arg3: 'bdd_ptr') -> "bdd_ptr":
    """bdd_imply(DdManager * arg1, bdd_ptr arg2, bdd_ptr arg3) -> bdd_ptr"""
    return _dd.bdd_imply(arg1, arg2, arg3)

def bdd_forsome(arg1: 'DdManager *', arg2: 'bdd_ptr', arg3: 'bdd_ptr') -> "bdd_ptr":
    """bdd_forsome(DdManager * arg1, bdd_ptr arg2, bdd_ptr arg3) -> bdd_ptr"""
    return _dd.bdd_forsome(arg1, arg2, arg3)

def bdd_forall(arg1: 'DdManager *', arg2: 'bdd_ptr', arg3: 'bdd_ptr') -> "bdd_ptr":
    """bdd_forall(DdManager * arg1, bdd_ptr arg2, bdd_ptr arg3) -> bdd_ptr"""
    return _dd.bdd_forall(arg1, arg2, arg3)

def bdd_permute(arg1: 'DdManager *', arg2: 'bdd_ptr', arg3: 'int *') -> "bdd_ptr":
    """bdd_permute(DdManager * arg1, bdd_ptr arg2, int * arg3) -> bdd_ptr"""
    return _dd.bdd_permute(arg1, arg2, arg3)

def bdd_and_abstract(arg1: 'DdManager *', arg2: 'bdd_ptr', arg3: 'bdd_ptr', arg4: 'bdd_ptr') -> "bdd_ptr":
    """bdd_and_abstract(DdManager * arg1, bdd_ptr arg2, bdd_ptr arg3, bdd_ptr arg4) -> bdd_ptr"""
    return _dd.bdd_and_abstract(arg1, arg2, arg3, arg4)

def bdd_simplify_assuming(arg1: 'DdManager *', arg2: 'bdd_ptr', arg3: 'bdd_ptr') -> "bdd_ptr":
    """bdd_simplify_assuming(DdManager * arg1, bdd_ptr arg2, bdd_ptr arg3) -> bdd_ptr"""
    return _dd.bdd_simplify_assuming(arg1, arg2, arg3)

def bdd_minimize(arg1: 'DdManager *', arg2: 'bdd_ptr', arg3: 'bdd_ptr') -> "bdd_ptr":
    """bdd_minimize(DdManager * arg1, bdd_ptr arg2, bdd_ptr arg3) -> bdd_ptr"""
    return _dd.bdd_minimize(arg1, arg2, arg3)

def bdd_cofactor(arg1: 'DdManager *', arg2: 'bdd_ptr', arg3: 'bdd_ptr') -> "bdd_ptr":
    """bdd_cofactor(DdManager * arg1, bdd_ptr arg2, bdd_ptr arg3) -> bdd_ptr"""
    return _dd.bdd_cofactor(arg1, arg2, arg3)

def bdd_between(arg1: 'DdManager *', arg2: 'bdd_ptr', arg3: 'bdd_ptr') -> "bdd_ptr":
    """bdd_between(DdManager * arg1, bdd_ptr arg2, bdd_ptr arg3) -> bdd_ptr"""
    return _dd.bdd_between(arg1, arg2, arg3)

def bdd_entailed(dd: 'DdManager *', f: 'bdd_ptr', g: 'bdd_ptr') -> "int":
    """bdd_entailed(DdManager * dd, bdd_ptr f, bdd_ptr g) -> int"""
    return _dd.bdd_entailed(dd, f, g)

def bdd_intersected(dd: 'DdManager *', f: 'bdd_ptr', g: 'bdd_ptr') -> "int":
    """bdd_intersected(DdManager * dd, bdd_ptr f, bdd_ptr g) -> int"""
    return _dd.bdd_intersected(dd, f, g)

def bdd_then(arg1: 'DdManager *', arg2: 'bdd_ptr') -> "bdd_ptr":
    """bdd_then(DdManager * arg1, bdd_ptr arg2) -> bdd_ptr"""
    return _dd.bdd_then(arg1, arg2)

def bdd_else(arg1: 'DdManager *', arg2: 'bdd_ptr') -> "bdd_ptr":
    """bdd_else(DdManager * arg1, bdd_ptr arg2) -> bdd_ptr"""
    return _dd.bdd_else(arg1, arg2)

def bdd_ite(arg1: 'DdManager *', arg2: 'bdd_ptr', arg3: 'bdd_ptr', arg4: 'bdd_ptr') -> "bdd_ptr":
    """bdd_ite(DdManager * arg1, bdd_ptr arg2, bdd_ptr arg3, bdd_ptr arg4) -> bdd_ptr"""
    return _dd.bdd_ite(arg1, arg2, arg3, arg4)

def bdd_iscomplement(arg1: 'DdManager *', arg2: 'bdd_ptr') -> "int":
    """bdd_iscomplement(DdManager * arg1, bdd_ptr arg2) -> int"""
    return _dd.bdd_iscomplement(arg1, arg2)

def bdd_readperm(arg1: 'DdManager *', arg2: 'bdd_ptr') -> "int":
    """bdd_readperm(DdManager * arg1, bdd_ptr arg2) -> int"""
    return _dd.bdd_readperm(arg1, arg2)

def bdd_index(arg1: 'DdManager *', arg2: 'bdd_ptr') -> "int":
    """bdd_index(DdManager * arg1, bdd_ptr arg2) -> int"""
    return _dd.bdd_index(arg1, arg2)

def bdd_pick_one_minterm(arg1: 'DdManager *', arg2: 'bdd_ptr', arg3: 'bdd_ptr *', arg4: 'int') -> "bdd_ptr":
    """bdd_pick_one_minterm(DdManager * arg1, bdd_ptr arg2, bdd_ptr * arg3, int arg4) -> bdd_ptr"""
    return _dd.bdd_pick_one_minterm(arg1, arg2, arg3, arg4)

def bdd_pick_one_minterm_rand(arg1: 'DdManager *', arg2: 'bdd_ptr', arg3: 'bdd_ptr *', arg4: 'int') -> "bdd_ptr":
    """bdd_pick_one_minterm_rand(DdManager * arg1, bdd_ptr arg2, bdd_ptr * arg3, int arg4) -> bdd_ptr"""
    return _dd.bdd_pick_one_minterm_rand(arg1, arg2, arg3, arg4)

def bdd_pick_all_terms(arg1: 'DdManager *', arg2: 'bdd_ptr', arg3: 'bdd_ptr *', arg4: 'int', arg5: 'bdd_ptr *', arg6: 'int') -> "int":
    """bdd_pick_all_terms(DdManager * arg1, bdd_ptr arg2, bdd_ptr * arg3, int arg4, bdd_ptr * arg5, int arg6) -> int"""
    return _dd.bdd_pick_all_terms(arg1, arg2, arg3, arg4, arg5, arg6)

def bdd_support(arg1: 'DdManager *', arg2: 'bdd_ptr') -> "bdd_ptr":
    """bdd_support(DdManager * arg1, bdd_ptr arg2) -> bdd_ptr"""
    return _dd.bdd_support(arg1, arg2)

def bdd_size(arg1: 'DdManager *', arg2: 'bdd_ptr') -> "int":
    """bdd_size(DdManager * arg1, bdd_ptr arg2) -> int"""
    return _dd.bdd_size(arg1, arg2)

def bdd_count_minterm(arg1: 'DdManager *', arg2: 'bdd_ptr', arg3: 'int') -> "double":
    """bdd_count_minterm(DdManager * arg1, bdd_ptr arg2, int arg3) -> double"""
    return _dd.bdd_count_minterm(arg1, arg2, arg3)

def bdd_new_var_with_index(arg1: 'DdManager *', arg2: 'int') -> "bdd_ptr":
    """bdd_new_var_with_index(DdManager * arg1, int arg2) -> bdd_ptr"""
    return _dd.bdd_new_var_with_index(arg1, arg2)

def bdd_get_one_sparse_sat(arg1: 'DdManager *', arg2: 'bdd_ptr') -> "bdd_ptr":
    """bdd_get_one_sparse_sat(DdManager * arg1, bdd_ptr arg2) -> bdd_ptr"""
    return _dd.bdd_get_one_sparse_sat(arg1, arg2)

def dd_set_parameters(arg1: 'DdManager *', arg2: 'OptsHandler_ptr', arg3: 'FILE *') -> "int":
    """dd_set_parameters(DdManager * arg1, OptsHandler_ptr arg2, FILE * arg3) -> int"""
    return _dd.dd_set_parameters(arg1, arg2, arg3)

def dd_print_stats(arg1: 'DdManager *', arg2: 'FILE *') -> "void":
    """dd_print_stats(DdManager * arg1, FILE * arg2)"""
    return _dd.dd_print_stats(arg1, arg2)

def bdd_cube_diff(arg1: 'DdManager *', arg2: 'bdd_ptr', arg3: 'bdd_ptr') -> "bdd_ptr":
    """bdd_cube_diff(DdManager * arg1, bdd_ptr arg2, bdd_ptr arg3) -> bdd_ptr"""
    return _dd.bdd_cube_diff(arg1, arg2, arg3)

def bdd_cube_union(arg1: 'DdManager *', arg2: 'bdd_ptr', arg3: 'bdd_ptr') -> "bdd_ptr":
    """bdd_cube_union(DdManager * arg1, bdd_ptr arg2, bdd_ptr arg3) -> bdd_ptr"""
    return _dd.bdd_cube_union(arg1, arg2, arg3)

def bdd_cube_intersection(arg1: 'DdManager *', arg2: 'bdd_ptr', arg3: 'bdd_ptr') -> "bdd_ptr":
    """bdd_cube_intersection(DdManager * arg1, bdd_ptr arg2, bdd_ptr arg3) -> bdd_ptr"""
    return _dd.bdd_cube_intersection(arg1, arg2, arg3)

def bdd_get_lowest_index(arg1: 'DdManager *', arg2: 'bdd_ptr') -> "int":
    """bdd_get_lowest_index(DdManager * arg1, bdd_ptr arg2) -> int"""
    return _dd.bdd_get_lowest_index(arg1, arg2)

def dd_printminterm(arg1: 'DdManager *', arg2: 'dd_ptr') -> "int":
    """dd_printminterm(DdManager * arg1, dd_ptr arg2) -> int"""
    return _dd.dd_printminterm(arg1, arg2)

def dd_dump_dot(arg1: 'DdManager *', arg2: 'int', arg3: 'dd_ptr *', arg4: 'char const **', arg5: 'char const **', arg6: 'FILE *') -> "int":
    """dd_dump_dot(DdManager * arg1, int arg2, dd_ptr * arg3, char const ** arg4, char const ** arg5, FILE * arg6) -> int"""
    return _dd.dd_dump_dot(arg1, arg2, arg3, arg4, arg5, arg6)

def dd_dump_davinci(arg1: 'DdManager *', arg2: 'int', arg3: 'dd_ptr *', arg4: 'char const **', arg5: 'char const **', arg6: 'FILE *') -> "int":
    """dd_dump_davinci(DdManager * arg1, int arg2, dd_ptr * arg3, char const ** arg4, char const ** arg5, FILE * arg6) -> int"""
    return _dd.dd_dump_davinci(arg1, arg2, arg3, arg4, arg5, arg6)

def dd_AddCmd() -> "void":
    """dd_AddCmd()"""
    return _dd.dd_AddCmd()

def bdd_largest_cube(arg1: 'DdManager *', arg2: 'bdd_ptr', arg3: 'int *') -> "bdd_ptr":
    """bdd_largest_cube(DdManager * arg1, bdd_ptr arg2, int * arg3) -> bdd_ptr"""
    return _dd.bdd_largest_cube(arg1, arg2, arg3)

def bdd_compute_prime_low(arg1: 'DdManager *', arg2: 'bdd_ptr', arg3: 'bdd_ptr') -> "bdd_ptr":
    """bdd_compute_prime_low(DdManager * arg1, bdd_ptr arg2, bdd_ptr arg3) -> bdd_ptr"""
    return _dd.bdd_compute_prime_low(arg1, arg2, arg3)

def bdd_compute_primes_low(arg1: 'DdManager *', arg2: 'bdd_ptr', arg3: 'bdd_ptr') -> "array_t *":
    """bdd_compute_primes_low(DdManager * arg1, bdd_ptr arg2, bdd_ptr arg3) -> array_t *"""
    return _dd.bdd_compute_primes_low(arg1, arg2, arg3)

def bdd_compute_primes(dd: 'DdManager *', b: 'bdd_ptr') -> "array_t *":
    """bdd_compute_primes(DdManager * dd, bdd_ptr b) -> array_t *"""
    return _dd.bdd_compute_primes(dd, b)

def bdd_make_prime(dd: 'DdManager *', cube: 'bdd_ptr', b: 'bdd_ptr') -> "bdd_ptr":
    """bdd_make_prime(DdManager * dd, bdd_ptr cube, bdd_ptr b) -> bdd_ptr"""
    return _dd.bdd_make_prime(dd, cube, b)

def bdd_compute_essentials(dd: 'DdManager *', b: 'bdd_ptr') -> "bdd_ptr":
    """bdd_compute_essentials(DdManager * dd, bdd_ptr b) -> bdd_ptr"""
    return _dd.bdd_compute_essentials(dd, b)

def bdd_DumpBlif(dd: 'DdManager *', n: 'int', f: 'bdd_ptr *', inames: 'char **', onames: 'char **', mname: 'char *', fp: 'FILE *') -> "int":
    """bdd_DumpBlif(DdManager * dd, int n, bdd_ptr * f, char ** inames, char ** onames, char * mname, FILE * fp) -> int"""
    return _dd.bdd_DumpBlif(dd, n, f, inames, onames, mname, fp)

def bdd_DumpBlifBody(dd: 'DdManager *', n: 'int', f: 'bdd_ptr *', inames: 'char **', onames: 'char **', fp: 'FILE *') -> "int":
    """bdd_DumpBlifBody(DdManager * dd, int n, bdd_ptr * f, char ** inames, char ** onames, FILE * fp) -> int"""
    return _dd.bdd_DumpBlifBody(dd, n, f, inames, onames, fp)

def bdd_leq(dd: 'DdManager *', f: 'bdd_ptr', g: 'bdd_ptr') -> "int":
    """bdd_leq(DdManager * dd, bdd_ptr f, bdd_ptr g) -> int"""
    return _dd.bdd_leq(dd, f, g)

def bdd_swap_variables(dd: 'DdManager *', f: 'bdd_ptr', x_varlist: 'bdd_ptr *', y_varlist: 'bdd_ptr *', n: 'int') -> "bdd_ptr":
    """bdd_swap_variables(DdManager * dd, bdd_ptr f, bdd_ptr * x_varlist, bdd_ptr * y_varlist, int n) -> bdd_ptr"""
    return _dd.bdd_swap_variables(dd, f, x_varlist, y_varlist, n)

def bdd_compose(dd: 'DdManager *', f: 'bdd_ptr', g: 'bdd_ptr', v: 'int') -> "bdd_ptr":
    """bdd_compose(DdManager * dd, bdd_ptr f, bdd_ptr g, int v) -> bdd_ptr"""
    return _dd.bdd_compose(dd, f, g, v)

def bdd_ref_count(n: 'bdd_ptr') -> "int":
    """bdd_ref_count(bdd_ptr n) -> int"""
    return _dd.bdd_ref_count(n)

def calculate_bdd_value(mgr: 'DdManager *', f: 'bdd_ptr', values: 'int *') -> "int":
    """calculate_bdd_value(DdManager * mgr, bdd_ptr f, int * values) -> int"""
    return _dd.calculate_bdd_value(mgr, f, values)

def VarsHandler_create(dd: 'DdManager *') -> "VarsHandler_ptr":
    """VarsHandler_create(DdManager * dd) -> VarsHandler_ptr"""
    return _dd.VarsHandler_create(dd)

def VarsHandler_destroy(arg1: 'VarsHandler_ptr') -> "void":
    """VarsHandler_destroy(VarsHandler_ptr arg1)"""
    return _dd.VarsHandler_destroy(arg1)

def VarsHandler_get_dd_manager(arg1: 'VarsHandler_ptr const') -> "DdManager *":
    """VarsHandler_get_dd_manager(VarsHandler_ptr const arg1) -> DdManager *"""
    return _dd.VarsHandler_get_dd_manager(arg1)

def VarsHandler_reserve_group(arg1: 'VarsHandler_ptr', from_lev: 'int', size: 'int', chunk: 'int', can_share: 'boolean', lev_low: 'int *') -> "GroupInfo_ptr":
    """VarsHandler_reserve_group(VarsHandler_ptr arg1, int from_lev, int size, int chunk, boolean can_share, int * lev_low) -> GroupInfo_ptr"""
    return _dd.VarsHandler_reserve_group(arg1, from_lev, size, chunk, can_share, lev_low)

def VarsHandler_can_group(arg1: 'VarsHandler_ptr const', from_lev: 'int', size: 'int', chunk: 'int') -> "boolean":
    """VarsHandler_can_group(VarsHandler_ptr const arg1, int from_lev, int size, int chunk) -> boolean"""
    return _dd.VarsHandler_can_group(arg1, from_lev, size, chunk)

def VarsHandler_release_group(arg1: 'VarsHandler_ptr', bid: 'GroupInfo_ptr') -> "boolean":
    """VarsHandler_release_group(VarsHandler_ptr arg1, GroupInfo_ptr bid) -> boolean"""
    return _dd.VarsHandler_release_group(arg1, bid)

def VarsHandler_dissolve_group(arg1: 'VarsHandler_ptr', bid: 'GroupInfo_ptr') -> "void":
    """VarsHandler_dissolve_group(VarsHandler_ptr arg1, GroupInfo_ptr bid)"""
    return _dd.VarsHandler_dissolve_group(arg1, bid)

def VarsHandler_update_levels(arg1: 'VarsHandler_ptr') -> "void":
    """VarsHandler_update_levels(VarsHandler_ptr arg1)"""
    return _dd.VarsHandler_update_levels(arg1)
# This file is compatible with both classic and new-style classes.


