# 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, '_be')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_be')
    _be = 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('_be', [dirname(__file__)])
        except ImportError:
            import _be
            return _be
        if fp is not None:
            try:
                _mod = imp.load_module('_be', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _be = swig_import_helper()
    del swig_import_helper
else:
    import _be
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 = _be.PRIuPTR
PRIdPTR = _be.PRIdPTR
LLU = _be.LLU
LLO = _be.LLO
LLX = _be.LLX
false = _be.false
true = _be.true
OUTCOME_GENERIC_ERROR = _be.OUTCOME_GENERIC_ERROR
OUTCOME_PARSER_ERROR = _be.OUTCOME_PARSER_ERROR
OUTCOME_SYNTAX_ERROR = _be.OUTCOME_SYNTAX_ERROR
OUTCOME_FILE_ERROR = _be.OUTCOME_FILE_ERROR
OUTCOME_SUCCESS_REQUIRED_HELP = _be.OUTCOME_SUCCESS_REQUIRED_HELP
OUTCOME_SUCCESS = _be.OUTCOME_SUCCESS

def Be_Init() -> "void":
    """Be_Init()"""
    return _be.Be_Init()

def Be_Quit() -> "void":
    """Be_Quit()"""
    return _be.Be_Quit()

def Be_Manager_Spec2Be(arg1: 'Be_Manager_ptr const', spec_expr: 'void *') -> "be_ptr":
    """Be_Manager_Spec2Be(Be_Manager_ptr const arg1, void * spec_expr) -> be_ptr"""
    return _be.Be_Manager_Spec2Be(arg1, spec_expr)

def Be_Manager_Be2Spec(arg1: 'Be_Manager_ptr const', be: 'be_ptr') -> "void *":
    """Be_Manager_Be2Spec(Be_Manager_ptr const arg1, be_ptr be) -> void *"""
    return _be.Be_Manager_Be2Spec(arg1, be)

def Be_Manager_GetSpecManager(arg1: 'Be_Manager_ptr') -> "void *":
    """Be_Manager_GetSpecManager(Be_Manager_ptr arg1) -> void *"""
    return _be.Be_Manager_GetSpecManager(arg1)

def Be_Cnf_Create(be: 'be_ptr const') -> "Be_Cnf_ptr":
    """Be_Cnf_Create(be_ptr const be) -> Be_Cnf_ptr"""
    return _be.Be_Cnf_Create(be)

def Be_Cnf_Delete(arg1: 'Be_Cnf_ptr') -> "void":
    """Be_Cnf_Delete(Be_Cnf_ptr arg1)"""
    return _be.Be_Cnf_Delete(arg1)

def Be_Cnf_RemoveDuplicateLiterals(arg1: 'Be_Cnf_ptr') -> "void":
    """Be_Cnf_RemoveDuplicateLiterals(Be_Cnf_ptr arg1)"""
    return _be.Be_Cnf_RemoveDuplicateLiterals(arg1)

def Be_Cnf_GetOriginalProblem(arg1: 'Be_Cnf_ptr const') -> "be_ptr":
    """Be_Cnf_GetOriginalProblem(Be_Cnf_ptr const arg1) -> be_ptr"""
    return _be.Be_Cnf_GetOriginalProblem(arg1)

def Be_Cnf_GetFormulaLiteral(arg1: 'Be_Cnf_ptr const') -> "int":
    """Be_Cnf_GetFormulaLiteral(Be_Cnf_ptr const arg1) -> int"""
    return _be.Be_Cnf_GetFormulaLiteral(arg1)

def Be_Cnf_GetVarsList(arg1: 'Be_Cnf_ptr const') -> "Slist_ptr":
    """Be_Cnf_GetVarsList(Be_Cnf_ptr const arg1) -> Slist_ptr"""
    return _be.Be_Cnf_GetVarsList(arg1)

def Be_Cnf_GetClausesList(arg1: 'Be_Cnf_ptr const') -> "Slist_ptr":
    """Be_Cnf_GetClausesList(Be_Cnf_ptr const arg1) -> Slist_ptr"""
    return _be.Be_Cnf_GetClausesList(arg1)

def Be_Cnf_GetMaxVarIndex(arg1: 'Be_Cnf_ptr const') -> "int":
    """Be_Cnf_GetMaxVarIndex(Be_Cnf_ptr const arg1) -> int"""
    return _be.Be_Cnf_GetMaxVarIndex(arg1)

def Be_Cnf_GetVarsNumber(arg1: 'Be_Cnf_ptr const') -> "size_t":
    """Be_Cnf_GetVarsNumber(Be_Cnf_ptr const arg1) -> size_t"""
    return _be.Be_Cnf_GetVarsNumber(arg1)

def Be_Cnf_GetClausesNumber(arg1: 'Be_Cnf_ptr const') -> "size_t":
    """Be_Cnf_GetClausesNumber(Be_Cnf_ptr const arg1) -> size_t"""
    return _be.Be_Cnf_GetClausesNumber(arg1)

def Be_Cnf_SetFormulaLiteral(arg1: 'Be_Cnf_ptr const', formula_literal: 'int const') -> "void":
    """Be_Cnf_SetFormulaLiteral(Be_Cnf_ptr const arg1, int const formula_literal)"""
    return _be.Be_Cnf_SetFormulaLiteral(arg1, formula_literal)

def Be_Cnf_SetMaxVarIndex(arg1: 'Be_Cnf_ptr const', max_idx: 'int const') -> "void":
    """Be_Cnf_SetMaxVarIndex(Be_Cnf_ptr const arg1, int const max_idx)"""
    return _be.Be_Cnf_SetMaxVarIndex(arg1, max_idx)

def Be_IsTrue(manager: 'Be_Manager_ptr', arg: 'be_ptr') -> "boolean":
    """Be_IsTrue(Be_Manager_ptr manager, be_ptr arg) -> boolean"""
    return _be.Be_IsTrue(manager, arg)

def Be_IsFalse(manager: 'Be_Manager_ptr', arg: 'be_ptr') -> "boolean":
    """Be_IsFalse(Be_Manager_ptr manager, be_ptr arg) -> boolean"""
    return _be.Be_IsFalse(manager, arg)

def Be_IsConstant(manager: 'Be_Manager_ptr', arg: 'be_ptr') -> "boolean":
    """Be_IsConstant(Be_Manager_ptr manager, be_ptr arg) -> boolean"""
    return _be.Be_IsConstant(manager, arg)

def Be_Truth(manager: 'Be_Manager_ptr') -> "be_ptr":
    """Be_Truth(Be_Manager_ptr manager) -> be_ptr"""
    return _be.Be_Truth(manager)

def Be_Falsity(manager: 'Be_Manager_ptr') -> "be_ptr":
    """Be_Falsity(Be_Manager_ptr manager) -> be_ptr"""
    return _be.Be_Falsity(manager)

def Be_Not(manager: 'Be_Manager_ptr', arg: 'be_ptr') -> "be_ptr":
    """Be_Not(Be_Manager_ptr manager, be_ptr arg) -> be_ptr"""
    return _be.Be_Not(manager, arg)

def Be_And(manager: 'Be_Manager_ptr', arg1: 'be_ptr', arg2: 'be_ptr') -> "be_ptr":
    """Be_And(Be_Manager_ptr manager, be_ptr arg1, be_ptr arg2) -> be_ptr"""
    return _be.Be_And(manager, arg1, arg2)

def Be_Or(manager: 'Be_Manager_ptr', arg1: 'be_ptr', arg2: 'be_ptr') -> "be_ptr":
    """Be_Or(Be_Manager_ptr manager, be_ptr arg1, be_ptr arg2) -> be_ptr"""
    return _be.Be_Or(manager, arg1, arg2)

def Be_Xor(manager: 'Be_Manager_ptr', arg1: 'be_ptr', arg2: 'be_ptr') -> "be_ptr":
    """Be_Xor(Be_Manager_ptr manager, be_ptr arg1, be_ptr arg2) -> be_ptr"""
    return _be.Be_Xor(manager, arg1, arg2)

def Be_Implies(manager: 'Be_Manager_ptr', arg1: 'be_ptr', arg2: 'be_ptr') -> "be_ptr":
    """Be_Implies(Be_Manager_ptr manager, be_ptr arg1, be_ptr arg2) -> be_ptr"""
    return _be.Be_Implies(manager, arg1, arg2)

def Be_Iff(manager: 'Be_Manager_ptr', arg1: 'be_ptr', arg2: 'be_ptr') -> "be_ptr":
    """Be_Iff(Be_Manager_ptr manager, be_ptr arg1, be_ptr arg2) -> be_ptr"""
    return _be.Be_Iff(manager, arg1, arg2)

def Be_Ite(manager: 'Be_Manager_ptr', arg_if: 'be_ptr', arg_then: 'be_ptr', arg_else: 'be_ptr') -> "be_ptr":
    """Be_Ite(Be_Manager_ptr manager, be_ptr arg_if, be_ptr arg_then, be_ptr arg_else) -> be_ptr"""
    return _be.Be_Ite(manager, arg_if, arg_then, arg_else)

def Be_LogicalShiftVar(manager: 'Be_Manager_ptr', f: 'be_ptr', shift: 'int', log2phy: 'int const *', phy2log: 'int const *') -> "be_ptr":
    """Be_LogicalShiftVar(Be_Manager_ptr manager, be_ptr f, int shift, int const * log2phy, int const * phy2log) -> be_ptr"""
    return _be.Be_LogicalShiftVar(manager, f, shift, log2phy, phy2log)

def Be_LogicalVarSubst(manager: 'Be_Manager_ptr', f: 'be_ptr', subst: 'int *', log2phy: 'int const *', phy2log: 'int const *') -> "be_ptr":
    """Be_LogicalVarSubst(Be_Manager_ptr manager, be_ptr f, int * subst, int const * log2phy, int const * phy2log) -> be_ptr"""
    return _be.Be_LogicalVarSubst(manager, f, subst, log2phy, phy2log)

def Be_ConvertToCnf(manager: 'Be_Manager_ptr', f: 'be_ptr', polarity: 'int') -> "Be_Cnf_ptr":
    """Be_ConvertToCnf(Be_Manager_ptr manager, be_ptr f, int polarity) -> Be_Cnf_ptr"""
    return _be.Be_ConvertToCnf(manager, f, polarity)

def Be_CnfLiteral2BeLiteral(arg1: 'Be_Manager_ptr const', cnfLiteral: 'int') -> "int":
    """Be_CnfLiteral2BeLiteral(Be_Manager_ptr const arg1, int cnfLiteral) -> int"""
    return _be.Be_CnfLiteral2BeLiteral(arg1, cnfLiteral)

def Be_BeLiteral2CnfLiteral(arg1: 'Be_Manager_ptr const', beLiteral: 'int') -> "int":
    """Be_BeLiteral2CnfLiteral(Be_Manager_ptr const arg1, int beLiteral) -> int"""
    return _be.Be_BeLiteral2CnfLiteral(arg1, beLiteral)

def Be_BeLiteral2BeIndex(arg1: 'Be_Manager_ptr const', beLiteral: 'int') -> "int":
    """Be_BeLiteral2BeIndex(Be_Manager_ptr const arg1, int beLiteral) -> int"""
    return _be.Be_BeLiteral2BeIndex(arg1, beLiteral)

def Be_BeIndex2BeLiteral(arg1: 'Be_Manager_ptr const', beIndex: 'int') -> "int":
    """Be_BeIndex2BeLiteral(Be_Manager_ptr const arg1, int beIndex) -> int"""
    return _be.Be_BeIndex2BeLiteral(arg1, beIndex)

def Be_BeIndex2CnfLiteral(arg1: 'Be_Manager_ptr const', beIndex: 'int') -> "int":
    """Be_BeIndex2CnfLiteral(Be_Manager_ptr const arg1, int beIndex) -> int"""
    return _be.Be_BeIndex2CnfLiteral(arg1, beIndex)

def Be_CnfModelToBeModel(manager: 'Be_Manager_ptr', cnfModel: 'Slist_ptr const') -> "Slist_ptr":
    """Be_CnfModelToBeModel(Be_Manager_ptr manager, Slist_ptr const cnfModel) -> Slist_ptr"""
    return _be.Be_CnfModelToBeModel(manager, cnfModel)

def Be_DumpDavinci(manager: 'Be_Manager_ptr', f: 'be_ptr', outFile: 'FILE *') -> "void":
    """Be_DumpDavinci(Be_Manager_ptr manager, be_ptr f, FILE * outFile)"""
    return _be.Be_DumpDavinci(manager, f, outFile)

def Be_DumpGdl(manager: 'Be_Manager_ptr', f: 'be_ptr', outFile: 'FILE *') -> "void":
    """Be_DumpGdl(Be_Manager_ptr manager, be_ptr f, FILE * outFile)"""
    return _be.Be_DumpGdl(manager, f, outFile)

def Be_DumpSexpr(manager: 'Be_Manager_ptr', f: 'be_ptr', outFile: 'FILE *') -> "void":
    """Be_DumpSexpr(Be_Manager_ptr manager, be_ptr f, FILE * outFile)"""
    return _be.Be_DumpSexpr(manager, f, outFile)

def Be_Index2Var(manager: 'Be_Manager_ptr', varIndex: 'int') -> "be_ptr":
    """Be_Index2Var(Be_Manager_ptr manager, int varIndex) -> be_ptr"""
    return _be.Be_Index2Var(manager, varIndex)

def Be_Var2Index(manager: 'Be_Manager_ptr', var: 'be_ptr') -> "int":
    """Be_Var2Index(Be_Manager_ptr manager, be_ptr var) -> int"""
    return _be.Be_Var2Index(manager, var)

def Be_CnfLiteral_IsSignPositive(arg1: 'Be_Manager_ptr const', cnfLiteral: 'int') -> "boolean":
    """Be_CnfLiteral_IsSignPositive(Be_Manager_ptr const arg1, int cnfLiteral) -> boolean"""
    return _be.Be_CnfLiteral_IsSignPositive(arg1, cnfLiteral)

def Be_CnfLiteral_Negate(arg1: 'Be_Manager_ptr const', cnfLiteral: 'int') -> "int":
    """Be_CnfLiteral_Negate(Be_Manager_ptr const arg1, int cnfLiteral) -> int"""
    return _be.Be_CnfLiteral_Negate(arg1, cnfLiteral)

def Be_BeLiteral_IsSignPositive(arg1: 'Be_Manager_ptr const', beLiteral: 'int') -> "boolean":
    """Be_BeLiteral_IsSignPositive(Be_Manager_ptr const arg1, int beLiteral) -> boolean"""
    return _be.Be_BeLiteral_IsSignPositive(arg1, beLiteral)

def Be_BeLiteral_Negate(arg1: 'Be_Manager_ptr const', beLiteral: 'int') -> "int":
    """Be_BeLiteral_Negate(Be_Manager_ptr const arg1, int beLiteral) -> int"""
    return _be.Be_BeLiteral_Negate(arg1, beLiteral)

def Be_apply_inlining(arg1: 'Be_Manager_ptr', f: 'be_ptr', add_conj: 'boolean') -> "be_ptr":
    """Be_apply_inlining(Be_Manager_ptr arg1, be_ptr f, boolean add_conj) -> be_ptr"""
    return _be.Be_apply_inlining(arg1, f, add_conj)

def Be_Cnf_PrintStat(arg1: 'Be_Cnf_ptr const', outFile: 'FILE *', prefix: 'char *') -> "void":
    """Be_Cnf_PrintStat(Be_Cnf_ptr const arg1, FILE * outFile, char * prefix)"""
    return _be.Be_Cnf_PrintStat(arg1, outFile, prefix)

def Be_RbcManager_Create(capacity: 'size_t const') -> "Be_Manager_ptr":
    """Be_RbcManager_Create(size_t const capacity) -> Be_Manager_ptr"""
    return _be.Be_RbcManager_Create(capacity)

def Be_RbcManager_Delete(arg1: 'Be_Manager_ptr') -> "void":
    """Be_RbcManager_Delete(Be_Manager_ptr arg1)"""
    return _be.Be_RbcManager_Delete(arg1)

def Be_RbcManager_Reserve(arg1: 'Be_Manager_ptr', size: 'size_t const') -> "void":
    """Be_RbcManager_Reserve(Be_Manager_ptr arg1, size_t const size)"""
    return _be.Be_RbcManager_Reserve(arg1, size)

def Be_RbcManager_Reset(arg1: 'Be_Manager_ptr const') -> "void":
    """Be_RbcManager_Reset(Be_Manager_ptr const arg1)"""
    return _be.Be_RbcManager_Reset(arg1)
# This file is compatible with both classic and new-style classes.

cvar = _be.cvar
BE_INVALID_SUBST_VALUE = cvar.BE_INVALID_SUBST_VALUE

