# 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, '_utils')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_utils')
    _utils = 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('_utils', [dirname(__file__)])
        except ImportError:
            import _utils
            return _utils
        if fp is not None:
            try:
                _mod = imp.load_module('_utils', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _utils = swig_import_helper()
    del swig_import_helper
else:
    import _utils
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

PRIuPTR = _utils.PRIuPTR
PRIdPTR = _utils.PRIdPTR
LLU = _utils.LLU
LLO = _utils.LLO
LLX = _utils.LLX
false = _utils.false
true = _utils.true
OUTCOME_GENERIC_ERROR = _utils.OUTCOME_GENERIC_ERROR
OUTCOME_PARSER_ERROR = _utils.OUTCOME_PARSER_ERROR
OUTCOME_SYNTAX_ERROR = _utils.OUTCOME_SYNTAX_ERROR
OUTCOME_FILE_ERROR = _utils.OUTCOME_FILE_ERROR
OUTCOME_SUCCESS_REQUIRED_HELP = _utils.OUTCOME_SUCCESS_REQUIRED_HELP
OUTCOME_SUCCESS = _utils.OUTCOME_SUCCESS

def AddArray_create(number: 'int') -> "AddArray_ptr":
    """AddArray_create(int number) -> AddArray_ptr"""
    return _utils.AddArray_create(number)

def AddArray_destroy(dd: 'DdManager *', arg2: 'AddArray_ptr') -> "void":
    """AddArray_destroy(DdManager * dd, AddArray_ptr arg2)"""
    return _utils.AddArray_destroy(dd, arg2)

def AddArray_from_word_number(dd: 'DdManager *', wn: 'WordNumber_ptr') -> "AddArray_ptr":
    """AddArray_from_word_number(DdManager * dd, WordNumber_ptr wn) -> AddArray_ptr"""
    return _utils.AddArray_from_word_number(dd, wn)

def AddArray_from_add(add: 'add_ptr') -> "AddArray_ptr":
    """AddArray_from_add(add_ptr add) -> AddArray_ptr"""
    return _utils.AddArray_from_add(add)

def AddArray_duplicate(arg1: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_duplicate(AddArray_ptr arg1) -> AddArray_ptr"""
    return _utils.AddArray_duplicate(arg1)

def AddArray_get_size(arg1: 'AddArray_ptr') -> "int":
    """AddArray_get_size(AddArray_ptr arg1) -> int"""
    return _utils.AddArray_get_size(arg1)

def AddArray_get_add_size(arg1: 'AddArray_ptr const', dd: 'DdManager *') -> "size_t":
    """AddArray_get_add_size(AddArray_ptr const arg1, DdManager * dd) -> size_t"""
    return _utils.AddArray_get_add_size(arg1, dd)

def AddArray_get_add(arg1: 'AddArray_ptr') -> "add_ptr":
    """AddArray_get_add(AddArray_ptr arg1) -> add_ptr"""
    return _utils.AddArray_get_add(arg1)

def AddArray_get_n(arg1: 'AddArray_ptr', number: 'int') -> "add_ptr":
    """AddArray_get_n(AddArray_ptr arg1, int number) -> add_ptr"""
    return _utils.AddArray_get_n(arg1, number)

def AddArray_set_n(arg1: 'AddArray_ptr', number: 'int', add: 'add_ptr') -> "void":
    """AddArray_set_n(AddArray_ptr arg1, int number, add_ptr add)"""
    return _utils.AddArray_set_n(arg1, number, add)

def AddArray_get_array(arg1: 'AddArray_ptr') -> "array_t *":
    """AddArray_get_array(AddArray_ptr arg1) -> array_t *"""
    return _utils.AddArray_get_array(arg1)

def AddArray_word_apply_unary(dd: 'DdManager *', arg1: 'AddArray_ptr', op: 'FP_A_DA') -> "AddArray_ptr":
    """AddArray_word_apply_unary(DdManager * dd, AddArray_ptr arg1, FP_A_DA op) -> AddArray_ptr"""
    return _utils.AddArray_word_apply_unary(dd, arg1, op)

def AddArray_word_apply_binary(dd: 'DdManager *', arg1: 'AddArray_ptr', arg2: 'AddArray_ptr', op: 'FP_A_DAA') -> "AddArray_ptr":
    """AddArray_word_apply_binary(DdManager * dd, AddArray_ptr arg1, AddArray_ptr arg2, FP_A_DAA op) -> AddArray_ptr"""
    return _utils.AddArray_word_apply_binary(dd, arg1, arg2, op)

def AddArray_make_disjunction(dd: 'DdManager *', arg: 'AddArray_ptr') -> "add_ptr":
    """AddArray_make_disjunction(DdManager * dd, AddArray_ptr arg) -> add_ptr"""
    return _utils.AddArray_make_disjunction(dd, arg)

def AddArray_make_conjunction(dd: 'DdManager *', arg: 'AddArray_ptr') -> "add_ptr":
    """AddArray_make_conjunction(DdManager * dd, AddArray_ptr arg) -> add_ptr"""
    return _utils.AddArray_make_conjunction(dd, arg)

def AddArray_word_plus(dd: 'DdManager *', arg1: 'AddArray_ptr', arg2: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_plus(DdManager * dd, AddArray_ptr arg1, AddArray_ptr arg2) -> AddArray_ptr"""
    return _utils.AddArray_word_plus(dd, arg1, arg2)

def AddArray_word_minus(dd: 'DdManager *', arg1: 'AddArray_ptr', arg2: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_minus(DdManager * dd, AddArray_ptr arg1, AddArray_ptr arg2) -> AddArray_ptr"""
    return _utils.AddArray_word_minus(dd, arg1, arg2)

def AddArray_word_unary_minus(dd: 'DdManager *', arg: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_unary_minus(DdManager * dd, AddArray_ptr arg) -> AddArray_ptr"""
    return _utils.AddArray_word_unary_minus(dd, arg)

def AddArray_word_times(dd: 'DdManager *', arg1: 'AddArray_ptr', arg2: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_times(DdManager * dd, AddArray_ptr arg1, AddArray_ptr arg2) -> AddArray_ptr"""
    return _utils.AddArray_word_times(dd, arg1, arg2)

def AddArray_word_unsigned_divide(dd: 'DdManager *', arg1: 'AddArray_ptr', arg2: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_unsigned_divide(DdManager * dd, AddArray_ptr arg1, AddArray_ptr arg2) -> AddArray_ptr"""
    return _utils.AddArray_word_unsigned_divide(dd, arg1, arg2)

def AddArray_word_unsigned_mod(dd: 'DdManager *', arg1: 'AddArray_ptr', arg2: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_unsigned_mod(DdManager * dd, AddArray_ptr arg1, AddArray_ptr arg2) -> AddArray_ptr"""
    return _utils.AddArray_word_unsigned_mod(dd, arg1, arg2)

def AddArray_word_signed_divide(dd: 'DdManager *', arg1: 'AddArray_ptr', arg2: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_signed_divide(DdManager * dd, AddArray_ptr arg1, AddArray_ptr arg2) -> AddArray_ptr"""
    return _utils.AddArray_word_signed_divide(dd, arg1, arg2)

def AddArray_word_signed_mod(dd: 'DdManager *', arg1: 'AddArray_ptr', arg2: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_signed_mod(DdManager * dd, AddArray_ptr arg1, AddArray_ptr arg2) -> AddArray_ptr"""
    return _utils.AddArray_word_signed_mod(dd, arg1, arg2)

def AddArray_word_left_shift(dd: 'DdManager *', arg: 'AddArray_ptr', number: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_left_shift(DdManager * dd, AddArray_ptr arg, AddArray_ptr number) -> AddArray_ptr"""
    return _utils.AddArray_word_left_shift(dd, arg, number)

def AddArray_word_unsigned_right_shift(dd: 'DdManager *', arg: 'AddArray_ptr', number: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_unsigned_right_shift(DdManager * dd, AddArray_ptr arg, AddArray_ptr number) -> AddArray_ptr"""
    return _utils.AddArray_word_unsigned_right_shift(dd, arg, number)

def AddArray_word_signed_right_shift(dd: 'DdManager *', arg: 'AddArray_ptr', number: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_signed_right_shift(DdManager * dd, AddArray_ptr arg, AddArray_ptr number) -> AddArray_ptr"""
    return _utils.AddArray_word_signed_right_shift(dd, arg, number)

def AddArray_word_left_rotate(dd: 'DdManager *', arg: 'AddArray_ptr', number: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_left_rotate(DdManager * dd, AddArray_ptr arg, AddArray_ptr number) -> AddArray_ptr"""
    return _utils.AddArray_word_left_rotate(dd, arg, number)

def AddArray_word_right_rotate(dd: 'DdManager *', arg: 'AddArray_ptr', number: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_right_rotate(DdManager * dd, AddArray_ptr arg, AddArray_ptr number) -> AddArray_ptr"""
    return _utils.AddArray_word_right_rotate(dd, arg, number)

def AddArray_word_unsigned_less(dd: 'DdManager *', arg1: 'AddArray_ptr', arg2: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_unsigned_less(DdManager * dd, AddArray_ptr arg1, AddArray_ptr arg2) -> AddArray_ptr"""
    return _utils.AddArray_word_unsigned_less(dd, arg1, arg2)

def AddArray_word_unsigned_less_equal(dd: 'DdManager *', arg1: 'AddArray_ptr', arg2: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_unsigned_less_equal(DdManager * dd, AddArray_ptr arg1, AddArray_ptr arg2) -> AddArray_ptr"""
    return _utils.AddArray_word_unsigned_less_equal(dd, arg1, arg2)

def AddArray_word_unsigned_greater(dd: 'DdManager *', arg1: 'AddArray_ptr', arg2: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_unsigned_greater(DdManager * dd, AddArray_ptr arg1, AddArray_ptr arg2) -> AddArray_ptr"""
    return _utils.AddArray_word_unsigned_greater(dd, arg1, arg2)

def AddArray_word_unsigned_greater_equal(dd: 'DdManager *', arg1: 'AddArray_ptr', arg2: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_unsigned_greater_equal(DdManager * dd, AddArray_ptr arg1, AddArray_ptr arg2) -> AddArray_ptr"""
    return _utils.AddArray_word_unsigned_greater_equal(dd, arg1, arg2)

def AddArray_word_signed_less(dd: 'DdManager *', arg1: 'AddArray_ptr', arg2: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_signed_less(DdManager * dd, AddArray_ptr arg1, AddArray_ptr arg2) -> AddArray_ptr"""
    return _utils.AddArray_word_signed_less(dd, arg1, arg2)

def AddArray_word_signed_less_equal(dd: 'DdManager *', arg1: 'AddArray_ptr', arg2: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_signed_less_equal(DdManager * dd, AddArray_ptr arg1, AddArray_ptr arg2) -> AddArray_ptr"""
    return _utils.AddArray_word_signed_less_equal(dd, arg1, arg2)

def AddArray_word_signed_greater(dd: 'DdManager *', arg1: 'AddArray_ptr', arg2: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_signed_greater(DdManager * dd, AddArray_ptr arg1, AddArray_ptr arg2) -> AddArray_ptr"""
    return _utils.AddArray_word_signed_greater(dd, arg1, arg2)

def AddArray_word_signed_greater_equal(dd: 'DdManager *', arg1: 'AddArray_ptr', arg2: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_signed_greater_equal(DdManager * dd, AddArray_ptr arg1, AddArray_ptr arg2) -> AddArray_ptr"""
    return _utils.AddArray_word_signed_greater_equal(dd, arg1, arg2)

def AddArray_word_signed_extend(dd: 'DdManager *', arg: 'AddArray_ptr', repeat: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_signed_extend(DdManager * dd, AddArray_ptr arg, AddArray_ptr repeat) -> AddArray_ptr"""
    return _utils.AddArray_word_signed_extend(dd, arg, repeat)

def AddArray_word_unsigned_extend(dd: 'DdManager *', arg: 'AddArray_ptr', repeat: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_unsigned_extend(DdManager * dd, AddArray_ptr arg, AddArray_ptr repeat) -> AddArray_ptr"""
    return _utils.AddArray_word_unsigned_extend(dd, arg, repeat)

def AddArray_word_signed_resize(dd: 'DdManager *', arg: 'AddArray_ptr', new_size: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_signed_resize(DdManager * dd, AddArray_ptr arg, AddArray_ptr new_size) -> AddArray_ptr"""
    return _utils.AddArray_word_signed_resize(dd, arg, new_size)

def AddArray_word_unsigned_resize(dd: 'DdManager *', arg: 'AddArray_ptr', new_size: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_unsigned_resize(DdManager * dd, AddArray_ptr arg, AddArray_ptr new_size) -> AddArray_ptr"""
    return _utils.AddArray_word_unsigned_resize(dd, arg, new_size)

def AddArray_word_equal(dd: 'DdManager *', arg1: 'AddArray_ptr', arg2: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_equal(DdManager * dd, AddArray_ptr arg1, AddArray_ptr arg2) -> AddArray_ptr"""
    return _utils.AddArray_word_equal(dd, arg1, arg2)

def AddArray_word_not_equal(dd: 'DdManager *', arg1: 'AddArray_ptr', arg2: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_not_equal(DdManager * dd, AddArray_ptr arg1, AddArray_ptr arg2) -> AddArray_ptr"""
    return _utils.AddArray_word_not_equal(dd, arg1, arg2)

def AddArray_word_ite(dd: 'DdManager *', _if: 'AddArray_ptr', _then: 'AddArray_ptr', _else: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_ite(DdManager * dd, AddArray_ptr _if, AddArray_ptr _then, AddArray_ptr _else) -> AddArray_ptr"""
    return _utils.AddArray_word_ite(dd, _if, _then, _else)

def AddArray_word_bit_selection(dd: 'DdManager *', word: 'AddArray_ptr', range: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_bit_selection(DdManager * dd, AddArray_ptr word, AddArray_ptr range) -> AddArray_ptr"""
    return _utils.AddArray_word_bit_selection(dd, word, range)

def AddArray_word_concatenation(dd: 'DdManager *', arg1: 'AddArray_ptr', arg2: 'AddArray_ptr') -> "AddArray_ptr":
    """AddArray_word_concatenation(DdManager * dd, AddArray_ptr arg1, AddArray_ptr arg2) -> AddArray_ptr"""
    return _utils.AddArray_word_concatenation(dd, arg1, arg2)

def OrdGroups_create() -> "OrdGroups_ptr":
    """OrdGroups_create() -> OrdGroups_ptr"""
    return _utils.OrdGroups_create()

def OrdGroups_copy(arg1: 'OrdGroups_ptr const') -> "OrdGroups_ptr":
    """OrdGroups_copy(OrdGroups_ptr const arg1) -> OrdGroups_ptr"""
    return _utils.OrdGroups_copy(arg1)

def OrdGroups_destroy(arg1: 'OrdGroups_ptr') -> "void":
    """OrdGroups_destroy(OrdGroups_ptr arg1)"""
    return _utils.OrdGroups_destroy(arg1)

def OrdGroups_create_group(arg1: 'OrdGroups_ptr') -> "int":
    """OrdGroups_create_group(OrdGroups_ptr arg1) -> int"""
    return _utils.OrdGroups_create_group(arg1)

def OrdGroups_add_variable(arg1: 'OrdGroups_ptr', name: 'node_ptr', group: 'int') -> "void":
    """OrdGroups_add_variable(OrdGroups_ptr arg1, node_ptr name, int group)"""
    return _utils.OrdGroups_add_variable(arg1, name, group)

def OrdGroups_add_variables(arg1: 'OrdGroups_ptr', vars: 'NodeList_ptr', group: 'int') -> "void":
    """OrdGroups_add_variables(OrdGroups_ptr arg1, NodeList_ptr vars, int group)"""
    return _utils.OrdGroups_add_variables(arg1, vars, group)

def OrdGroups_get_vars_in_group(arg1: 'OrdGroups_ptr const', group: 'int') -> "NodeList_ptr":
    """OrdGroups_get_vars_in_group(OrdGroups_ptr const arg1, int group) -> NodeList_ptr"""
    return _utils.OrdGroups_get_vars_in_group(arg1, group)

def OrdGroups_get_var_group(arg1: 'OrdGroups_ptr const', name: 'node_ptr') -> "int":
    """OrdGroups_get_var_group(OrdGroups_ptr const arg1, node_ptr name) -> int"""
    return _utils.OrdGroups_get_var_group(arg1, name)

def OrdGroups_get_size(arg1: 'OrdGroups_ptr const') -> "int":
    """OrdGroups_get_size(OrdGroups_ptr const arg1) -> int"""
    return _utils.OrdGroups_get_size(arg1)
# This file is compatible with both classic and new-style classes.


