Changes to be able to compile ABC without CUDD.

35 files changed, 0 insertions, 15115 deletions

diff --git a/src/proof/bbr/bbr.h b/src/proof/bbr/bbr.h
deleted file mode 100644
index 1db638e8..00000000
--- a/src/proof/bbr/bbr.h
+++ /dev/null
@@ -1,93 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [bbr.h]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD-based reachability analysis.]
-
-  Synopsis    [External declarations.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: bbr.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
- 
-#ifndef ABC__aig__bbr__bbr_h
-#define ABC__aig__bbr__bbr_h
-
-
-////////////////////////////////////////////////////////////////////////
-///                          INCLUDES                                ///
-////////////////////////////////////////////////////////////////////////
-
-#include <stdio.h>
-#include "aig/aig/aig.h"
-#include "aig/saig/saig.h"
-#include "bdd/cudd/cuddInt.h"
-
-////////////////////////////////////////////////////////////////////////
-///                         PARAMETERS                               ///
-////////////////////////////////////////////////////////////////////////
-
-
-
-ABC_NAMESPACE_HEADER_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                         BASIC TYPES                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                      MACRO DEFINITIONS                           ///
-////////////////////////////////////////////////////////////////////////
-
-static inline DdNode * Aig_ObjGlobalBdd( Aig_Obj_t * pObj )  { return (DdNode *)pObj->pData; }
-
-////////////////////////////////////////////////////////////////////////
-///                    FUNCTION DECLARATIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/*=== bbrImage.c ==========================================================*/
-typedef struct Bbr_ImageTree_t_  Bbr_ImageTree_t;
-extern Bbr_ImageTree_t * Bbr_bddImageStart( 
-    DdManager * dd, DdNode * bCare,
-    int nParts, DdNode ** pbParts,
-    int nVars, DdNode ** pbVars, int nBddMax, int fVerbose );
-extern DdNode *    Bbr_bddImageCompute( Bbr_ImageTree_t * pTree, DdNode * bCare );
-extern void        Bbr_bddImageTreeDelete( Bbr_ImageTree_t * pTree );
-extern DdNode *    Bbr_bddImageRead( Bbr_ImageTree_t * pTree );
-typedef struct Bbr_ImageTree2_t_  Bbr_ImageTree2_t;
-extern Bbr_ImageTree2_t * Bbr_bddImageStart2( 
-    DdManager * dd, DdNode * bCare,
-    int nParts, DdNode ** pbParts,
-    int nVars, DdNode ** pbVars, int fVerbose );
-extern DdNode *    Bbr_bddImageCompute2( Bbr_ImageTree2_t * pTree, DdNode * bCare );
-extern void        Bbr_bddImageTreeDelete2( Bbr_ImageTree2_t * pTree );
-extern DdNode *    Bbr_bddImageRead2( Bbr_ImageTree2_t * pTree );
-/*=== bbrNtbdd.c ==========================================================*/
-extern void        Aig_ManFreeGlobalBdds( Aig_Man_t * p, DdManager * dd );
-extern int         Aig_ManSizeOfGlobalBdds( Aig_Man_t * p );
-extern DdManager * Aig_ManComputeGlobalBdds( Aig_Man_t * p, int nBddSizeMax, int fDropInternal, int fReorder, int fVerbose );
-/*=== bbrReach.c ==========================================================*/
-extern int         Aig_ManVerifyUsingBdds( Aig_Man_t * p, Saig_ParBbr_t * pPars );
-extern void        Bbr_ManSetDefaultParams( Saig_ParBbr_t * p );
-
-
-
-ABC_NAMESPACE_HEADER_END
-
-
-
-#endif
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
diff --git a/src/proof/bbr/bbrCex.c b/src/proof/bbr/bbrCex.c
deleted file mode 100644
index 31a46d61..00000000
--- a/src/proof/bbr/bbrCex.c
+++ /dev/null
@@ -1,172 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [bbrCex.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD-based reachability analysis.]
-
-  Synopsis    [Procedures to derive a satisfiable counter-example.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: bbrCex.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "bbr.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-extern DdNode * Bbr_bddComputeRangeCube( DdManager * dd, int iStart, int iStop );
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Derives the counter-example using the set of reached states.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Abc_Cex_t * Aig_ManVerifyUsingBddsCountExample( Aig_Man_t * p, DdManager * dd, 
-    DdNode ** pbParts, Vec_Ptr_t * vOnionRings, DdNode * bCubeFirst,
-    int iOutput, int fVerbose, int fSilent )
-{
-    Abc_Cex_t * pCex;
-    Aig_Obj_t * pObj;
-    Bbr_ImageTree_t * pTree;
-    DdNode * bCubeNs, * bState, * bImage;
-    DdNode * bTemp, * bVar, * bRing;
-    int i, v, RetValue, nPiOffset;
-    char * pValues;
-    abctime clk = Abc_Clock();
-//printf( "\nDeriving counter-example.\n" );
-
-    // allocate room for the counter-example
-    pCex = Abc_CexAlloc( Saig_ManRegNum(p), Saig_ManPiNum(p), Vec_PtrSize(vOnionRings)+1 );
-    pCex->iFrame = Vec_PtrSize(vOnionRings);
-    pCex->iPo = iOutput;
-    nPiOffset = Saig_ManRegNum(p) + Saig_ManPiNum(p) * Vec_PtrSize(vOnionRings);
-
-    // create the cube of NS variables
-    bCubeNs  = Bbr_bddComputeRangeCube( dd, Saig_ManCiNum(p), Saig_ManCiNum(p)+Saig_ManRegNum(p) );    Cudd_Ref( bCubeNs );
-    pTree = Bbr_bddImageStart( dd, bCubeNs, Saig_ManRegNum(p), pbParts, Saig_ManCiNum(p), dd->vars, 100000000, fVerbose );
-    Cudd_RecursiveDeref( dd, bCubeNs );
-    if ( pTree == NULL )
-    {
-        if ( !fSilent )
-            printf( "BDDs blew up during qualitification scheduling.  " );
-        return NULL;
-    }
-
-    // allocate room for the cube
-    pValues = ABC_ALLOC( char, dd->size );
-
-    // get the last cube
-    RetValue = Cudd_bddPickOneCube( dd, bCubeFirst, pValues );
-    assert( RetValue );
-
-    // write PIs of counter-example
-    Saig_ManForEachPi( p, pObj, i )
-        if ( pValues[i] == 1 )
-            Abc_InfoSetBit( pCex->pData, nPiOffset + i );
-    nPiOffset -= Saig_ManPiNum(p);
-
-    // write state in terms of NS variables
-    bState = (dd)->one; Cudd_Ref( bState );
-    Saig_ManForEachLo( p, pObj, i )
-    {
-        bVar = Cudd_NotCond( dd->vars[Saig_ManCiNum(p)+i], pValues[Saig_ManPiNum(p)+i] != 1 );
-        bState = Cudd_bddAnd( dd, bTemp = bState, bVar );  Cudd_Ref( bState );
-        Cudd_RecursiveDeref( dd, bTemp ); 
-    }
-
-    // perform backward analysis
-    Vec_PtrForEachEntryReverse( DdNode *, vOnionRings, bRing, v )
-    { 
-        // compute the next states
-        bImage = Bbr_bddImageCompute( pTree, bState );           
-        if ( bImage == NULL )
-        {
-            Cudd_RecursiveDeref( dd, bState );
-            if ( !fSilent )
-                printf( "BDDs blew up during image computation.  " );
-            Bbr_bddImageTreeDelete( pTree );
-            ABC_FREE( pValues );
-            return NULL;
-        }
-        Cudd_Ref( bImage );
-        Cudd_RecursiveDeref( dd, bState );
-
-        // intersect with the previous set
-        bImage = Cudd_bddAnd( dd, bTemp = bImage, bRing );  Cudd_Ref( bImage );
-        Cudd_RecursiveDeref( dd, bTemp );
-
-        // find any assignment of the BDD
-        RetValue = Cudd_bddPickOneCube( dd, bImage, pValues );
-        assert( RetValue );
-        Cudd_RecursiveDeref( dd, bImage );
-
-        // write PIs of counter-example
-        Saig_ManForEachPi( p, pObj, i )
-            if ( pValues[i] == 1 )
-                Abc_InfoSetBit( pCex->pData, nPiOffset + i );
-        nPiOffset -= Saig_ManPiNum(p);
-
-        // check that we get the init state
-        if ( v == 0 )
-        {
-            Saig_ManForEachLo( p, pObj, i )
-                assert( pValues[Saig_ManPiNum(p)+i] == 0 );
-            break;
-        }
-
-        // write state in terms of NS variables
-        bState = (dd)->one; Cudd_Ref( bState );
-        Saig_ManForEachLo( p, pObj, i )
-        {
-            bVar = Cudd_NotCond( dd->vars[Saig_ManCiNum(p)+i], pValues[Saig_ManPiNum(p)+i] != 1 );
-            bState = Cudd_bddAnd( dd, bTemp = bState, bVar );  Cudd_Ref( bState );
-            Cudd_RecursiveDeref( dd, bTemp ); 
-        }
-    }
-    // cleanup
-    Bbr_bddImageTreeDelete( pTree );
-    ABC_FREE( pValues );
-    // verify the counter example
-    if ( Vec_PtrSize(vOnionRings) < 1000 )
-    {
-    RetValue = Saig_ManVerifyCex( p, pCex );
-    if ( RetValue == 0 && !fSilent )
-        printf( "Aig_ManVerifyUsingBdds(): Counter-example verification has FAILED.\n" );
-    }
-    if ( fVerbose && !fSilent )
-    {
-    ABC_PRT( "Counter-example generation time", Abc_Clock() - clk );
-    }
-    return pCex;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/bbr/bbrImage.c b/src/proof/bbr/bbrImage.c
deleted file mode 100644
index 1ff3d0b6..00000000
--- a/src/proof/bbr/bbrImage.c
+++ /dev/null
@@ -1,1327 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [bbrImage.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD-based reachability analysis.]
-
-  Synopsis    [Performs image computation.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: bbrImage.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "bbr.h"
-#include "bdd/mtr/mtr.h"
-
-ABC_NAMESPACE_IMPL_START
- 
-
-/* 
-    The ideas implemented in this file are inspired by the paper:
-    Pankaj Chauhan, Edmund Clarke, Somesh Jha, Jim Kukula, Tom Shiple, 
-    Helmut Veith, Dong Wang. Non-linear Quantification Scheduling in 
-    Image Computation. ICCAD, 2001.
-*/
- 
-/*---------------------------------------------------------------------------*/
-/* Constant declarations                                                     */
-/*---------------------------------------------------------------------------*/
-
-/*---------------------------------------------------------------------------*/
-/* Stucture declarations                                                     */
-/*---------------------------------------------------------------------------*/
-
-typedef struct Bbr_ImageNode_t_  Bbr_ImageNode_t;
-typedef struct Bbr_ImagePart_t_  Bbr_ImagePart_t;
-typedef struct Bbr_ImageVar_t_   Bbr_ImageVar_t;
-
-struct Bbr_ImageTree_t_
-{
-    Bbr_ImageNode_t *   pRoot;      // the root of quantification tree
-    Bbr_ImageNode_t *   pCare;      // the leaf node with the care set
-    DdNode *            bCareSupp;  // the cube to quantify from the care
-    int                 fVerbose;   // the verbosity flag
-    int                 nNodesMax;  // the max number of nodes in one iter
-    int                 nNodesMaxT; // the overall max number of nodes
-    int                 nIter;      // the number of iterations with this tree
-    int                 nBddMax;    // the number of node to stop
-};
-
-struct Bbr_ImageNode_t_
-{
-    DdManager *         dd;         // the manager 
-    DdNode *            bCube;      // the cube to quantify
-    DdNode *            bImage;     // the partial image
-    Bbr_ImageNode_t *   pNode1;     // the first branch
-    Bbr_ImageNode_t *   pNode2;     // the second branch
-    Bbr_ImagePart_t *   pPart;      // the partition (temporary)
-};
-
-struct Bbr_ImagePart_t_
-{
-    DdNode *            bFunc;      // the partition
-    DdNode *            bSupp;      // the support of this partition
-    int                 nNodes;     // the number of BDD nodes
-    short               nSupp;      // the number of support variables
-    short               iPart;      // the number of this partition
-};
-
-struct Bbr_ImageVar_t_
-{
-    int                 iNum;       // the BDD index of this variable
-    DdNode *            bParts;     // the partition numbers
-    int                 nParts;     // the number of partitions
-};
-
-/*---------------------------------------------------------------------------*/
-/* Type declarations                                                         */
-/*---------------------------------------------------------------------------*/
-
-/*---------------------------------------------------------------------------*/
-/* Variable declarations                                                     */
-/*---------------------------------------------------------------------------*/
-
-/*---------------------------------------------------------------------------*/
-/* Macro declarations                                                        */
-/*---------------------------------------------------------------------------*/
-
-#define     b0     Cudd_Not((dd)->one)
-#define     b1              (dd)->one
-
-#ifndef ABC_PRB
-#define ABC_PRB(dd,f)       printf("%s = ", #f); Bbr_bddPrint(dd,f); printf("\n")
-#endif
-
-/**AutomaticStart*************************************************************/
-
-
-/*---------------------------------------------------------------------------*/
-/* Static function prototypes                                                */
-/*---------------------------------------------------------------------------*/
-
-static Bbr_ImagePart_t ** Bbr_CreateParts( DdManager * dd,
-    int nParts, DdNode ** pbParts, DdNode * bCare );
-static Bbr_ImageVar_t ** Bbr_CreateVars( DdManager * dd,
-    int nParts, Bbr_ImagePart_t ** pParts,
-    int nVars, DdNode ** pbVarsNs );
-static Bbr_ImageNode_t ** Bbr_CreateNodes( DdManager * dd, 
-    int nParts, Bbr_ImagePart_t ** pParts, 
-    int nVars,  Bbr_ImageVar_t ** pVars );
-static void Bbr_DeleteParts_rec( Bbr_ImageNode_t * pNode );
-static int Bbr_BuildTreeNode( DdManager * dd, 
-    int nNodes, Bbr_ImageNode_t ** pNodes, 
-    int nVars,  Bbr_ImageVar_t ** pVars, int * pfStop, int nBddMax );
-static Bbr_ImageNode_t * Bbr_MergeTopNodes( DdManager * dd, 
-    int nNodes, Bbr_ImageNode_t ** pNodes );
-static void Bbr_bddImageTreeDelete_rec( Bbr_ImageNode_t * pNode );
-static int Bbr_bddImageCompute_rec( Bbr_ImageTree_t * pTree, Bbr_ImageNode_t * pNode );
-static int Bbr_FindBestVariable( DdManager * dd,
-    int nNodes, Bbr_ImageNode_t ** pNodes, 
-    int nVars,  Bbr_ImageVar_t ** pVars );
-static void Bbr_FindBestPartitions( DdManager * dd, DdNode * bParts, 
-    int nNodes, Bbr_ImageNode_t ** pNodes, 
-    int * piNode1, int * piNode2 );
-static Bbr_ImageNode_t * Bbr_CombineTwoNodes( DdManager * dd, DdNode * bCube,
-    Bbr_ImageNode_t * pNode1, Bbr_ImageNode_t * pNode2 );
-
-static void Bbr_bddImagePrintLatchDependency( DdManager * dd, DdNode * bCare,
-    int nParts, DdNode ** pbParts,
-    int nVars, DdNode ** pbVars );
-static void Bbr_bddImagePrintLatchDependencyOne( DdManager * dd, DdNode * bFunc, 
-    DdNode * bVarsCs, DdNode * bVarsNs, int iPart );
-
-static void Bbr_bddImagePrintTree( Bbr_ImageTree_t * pTree );
-static void Bbr_bddImagePrintTree_rec( Bbr_ImageNode_t * pNode, int nOffset );
-
-static void Bbr_bddPrint( DdManager * dd, DdNode * F );
-
-/**AutomaticEnd***************************************************************/
-
-
-/*---------------------------------------------------------------------------*/
-/* Definition of exported functions                                          */
-/*---------------------------------------------------------------------------*/
-
-/**Function*************************************************************
-
-  Synopsis    [Starts the image computation using tree-based scheduling.]
-
-  Description [This procedure starts the image computation. It uses
-  the given care set to test-run the image computation and creates the 
-  quantification tree by scheduling variable quantifications. The tree can 
-  be used to compute images for other care sets without rescheduling.
-  In this case, Bbr_bddImageCompute() should be called.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Bbr_ImageTree_t * Bbr_bddImageStart( 
-    DdManager * dd, DdNode * bCare, // the care set
-    int nParts, DdNode ** pbParts,  // the partitions for image computation
-    int nVars, DdNode ** pbVars, int nBddMax, int fVerbose )   // the NS and parameter variables (not quantified!)
-{
-    Bbr_ImageTree_t * pTree;
-    Bbr_ImagePart_t ** pParts;
-    Bbr_ImageVar_t ** pVars;
-    Bbr_ImageNode_t ** pNodes, * pCare;
-    int fStop, v;
-
-    if ( fVerbose && dd->size <= 80 )
-        Bbr_bddImagePrintLatchDependency( dd, bCare, nParts, pbParts, nVars, pbVars );
-
-    // create variables, partitions and leaf nodes
-    pParts = Bbr_CreateParts( dd, nParts, pbParts, bCare );
-    pVars  = Bbr_CreateVars( dd, nParts + 1, pParts, nVars, pbVars );
-    pNodes = Bbr_CreateNodes( dd, nParts + 1, pParts, dd->size, pVars );
-    pCare  = pNodes[nParts];
-
-    // process the nodes
-    while ( Bbr_BuildTreeNode( dd, nParts + 1, pNodes, dd->size, pVars, &fStop, nBddMax ) );
-
-    // consider the case of BDD node blowup
-    if ( fStop )
-    {
-        for ( v = 0; v < dd->size; v++ )
-            if ( pVars[v] )
-                ABC_FREE( pVars[v] );
-        ABC_FREE( pVars );
-        for ( v = 0; v <= nParts; v++ )
-            if ( pNodes[v] )
-            {
-                Bbr_DeleteParts_rec( pNodes[v] );
-                Bbr_bddImageTreeDelete_rec( pNodes[v] );
-            }
-        ABC_FREE( pNodes );
-        ABC_FREE( pParts );
-        return NULL;
-    }
-
-    // make sure the variables are gone
-    for ( v = 0; v < dd->size; v++ )
-        assert( pVars[v] == NULL );
-    ABC_FREE( pVars );
-    
-    // create the tree
-    pTree = ABC_ALLOC( Bbr_ImageTree_t, 1 );
-    memset( pTree, 0, sizeof(Bbr_ImageTree_t) );
-    pTree->pCare = pCare;
-    pTree->nBddMax = nBddMax;
-    pTree->fVerbose = fVerbose;
-
-    // merge the topmost nodes
-    while ( (pTree->pRoot = Bbr_MergeTopNodes( dd, nParts + 1, pNodes )) == NULL );
-
-    // make sure the nodes are gone
-    for ( v = 0; v < nParts + 1; v++ )
-        assert( pNodes[v] == NULL );
-    ABC_FREE( pNodes );
-
-//    if ( fVerbose )
-//        Bbr_bddImagePrintTree( pTree );
-
-    // set the support of the care set
-    pTree->bCareSupp = Cudd_Support( dd, bCare );  Cudd_Ref( pTree->bCareSupp );
-
-    // clean the partitions
-    Bbr_DeleteParts_rec( pTree->pRoot );
-    ABC_FREE( pParts );
-
-    return pTree;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Compute the image.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Bbr_bddImageCompute( Bbr_ImageTree_t * pTree, DdNode * bCare )
-{
-    DdManager * dd = pTree->pCare->dd;
-    DdNode * bSupp, * bRem;
-
-    pTree->nIter++;
-
-    // make sure the supports are okay
-    bSupp = Cudd_Support( dd, bCare );        Cudd_Ref( bSupp );
-    if ( bSupp != pTree->bCareSupp )
-    {
-        bRem = Cudd_bddExistAbstract( dd, bSupp, pTree->bCareSupp );  Cudd_Ref( bRem );
-        if ( bRem != b1 )
-        {
-printf( "Original care set support: " );
-ABC_PRB( dd, pTree->bCareSupp );
-printf( "Current care set support: " );
-ABC_PRB( dd, bSupp );
-            Cudd_RecursiveDeref( dd, bSupp );
-            Cudd_RecursiveDeref( dd, bRem );
-            printf( "The care set depends on some vars that were not in the care set during scheduling.\n" );
-            return NULL;
-        }
-        Cudd_RecursiveDeref( dd, bRem );
-    }
-    Cudd_RecursiveDeref( dd, bSupp );
-
-    // remove the previous image
-    Cudd_RecursiveDeref( dd, pTree->pCare->bImage );
-    pTree->pCare->bImage = bCare;   Cudd_Ref( bCare );
-
-    // compute the image
-    pTree->nNodesMax = 0;
-    if ( !Bbr_bddImageCompute_rec( pTree, pTree->pRoot ) )
-        return NULL;
-    if ( pTree->nNodesMaxT < pTree->nNodesMax )
-        pTree->nNodesMaxT = pTree->nNodesMax;
-
-//    if ( pTree->fVerbose )
-//        printf( "Iter %2d : Max nodes = %5d.\n", pTree->nIter, pTree->nNodesMax );
-    return pTree->pRoot->bImage;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Delete the tree.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Bbr_bddImageTreeDelete( Bbr_ImageTree_t * pTree )
-{
-    if ( pTree->bCareSupp )
-        Cudd_RecursiveDeref( pTree->pRoot->dd, pTree->bCareSupp );
-    Bbr_bddImageTreeDelete_rec( pTree->pRoot );
-    ABC_FREE( pTree );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Reads the image from the tree.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Bbr_bddImageRead( Bbr_ImageTree_t * pTree )
-{
-    return pTree->pRoot->bImage;
-}
-
-/*---------------------------------------------------------------------------*/
-/* Definition of internal functions                                          */
-/*---------------------------------------------------------------------------*/
-
-/**Function********************************************************************
-
-  Synopsis    [Outputs the BDD in a readable format.]
-
-  Description []
-
-  SideEffects [None]
-
-  SeeAlso     []
-
-******************************************************************************/
-void Bbr_bddPrint( DdManager * dd, DdNode * F )
-{
-    DdGen * Gen;
-    int * Cube;
-    CUDD_VALUE_TYPE Value;
-    int nVars = dd->size;
-    int fFirstCube = 1;
-    int i;
-
-    if ( F == NULL )
-    {
-        printf("NULL");
-        return;
-    }
-    if ( F == b0 )
-    {
-        printf("Constant 0");
-        return;
-    }
-    if ( F == b1 )
-    {
-        printf("Constant 1");
-        return;
-    }
-
-    Cudd_ForeachCube( dd, F, Gen, Cube, Value )
-    {
-        if ( fFirstCube )
-            fFirstCube = 0;
-        else
-//          Output << " + ";
-            printf( " + " );
-
-        for ( i = 0; i < nVars; i++ )
-            if ( Cube[i] == 0 )
-                printf( "[%d]'", i );
-//              printf( "%c'", (char)('a'+i) );
-            else if ( Cube[i] == 1 )
-                printf( "[%d]", i );
-//              printf( "%c", (char)('a'+i) );
-    }
-
-//  printf("\n");
-}
-
-/*---------------------------------------------------------------------------*/
-/* Definition of static Functions                                            */
-/*---------------------------------------------------------------------------*/
-
-/**Function*************************************************************
-
-  Synopsis    [Creates partitions.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Bbr_ImagePart_t ** Bbr_CreateParts( DdManager * dd,
-    int nParts, DdNode ** pbParts, DdNode * bCare )
-{
-    Bbr_ImagePart_t ** pParts;
-    int i;
-
-    // start the partitions
-    pParts = ABC_ALLOC( Bbr_ImagePart_t *, nParts + 1 );
-    // create structures for each variable
-    for ( i = 0; i < nParts; i++ )
-    {
-        pParts[i] = ABC_ALLOC( Bbr_ImagePart_t, 1 );
-        pParts[i]->bFunc  = pbParts[i];                           Cudd_Ref( pParts[i]->bFunc );
-        pParts[i]->bSupp  = Cudd_Support( dd, pParts[i]->bFunc ); Cudd_Ref( pParts[i]->bSupp );
-        pParts[i]->nSupp  = Cudd_SupportSize( dd, pParts[i]->bSupp );
-        pParts[i]->nNodes = Cudd_DagSize( pParts[i]->bFunc );
-        pParts[i]->iPart  = i;
-    }
-    // add the care set as the last partition
-    pParts[nParts] = ABC_ALLOC( Bbr_ImagePart_t, 1 );
-    pParts[nParts]->bFunc = bCare;                                     Cudd_Ref( pParts[nParts]->bFunc );
-    pParts[nParts]->bSupp = Cudd_Support( dd, pParts[nParts]->bFunc ); Cudd_Ref( pParts[nParts]->bSupp );
-    pParts[nParts]->nSupp = Cudd_SupportSize( dd, pParts[nParts]->bSupp );
-    pParts[nParts]->nNodes = Cudd_DagSize( pParts[nParts]->bFunc );
-    pParts[nParts]->iPart  = nParts;
-    return pParts;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Creates variables.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Bbr_ImageVar_t ** Bbr_CreateVars( DdManager * dd,
-    int nParts, Bbr_ImagePart_t ** pParts,
-    int nVars, DdNode ** pbVars )
-{
-    Bbr_ImageVar_t ** pVars;
-    DdNode ** pbFuncs;
-    DdNode * bCubeNs, * bSupp, * bParts, * bTemp, * bSuppTemp;
-    int nVarsTotal, iVar, p, Counter;
-
-    // put all the functions into one array
-    pbFuncs = ABC_ALLOC( DdNode *, nParts );
-    for ( p = 0; p < nParts; p++ )
-        pbFuncs[p] = pParts[p]->bSupp;
-    bSupp = Cudd_VectorSupport( dd, pbFuncs, nParts );  Cudd_Ref( bSupp );
-    ABC_FREE( pbFuncs );
-
-    // remove the NS vars
-    bCubeNs = Cudd_bddComputeCube( dd, pbVars, NULL, nVars );        Cudd_Ref( bCubeNs );
-    bSupp = Cudd_bddExistAbstract( dd, bTemp = bSupp, bCubeNs );     Cudd_Ref( bSupp );
-    Cudd_RecursiveDeref( dd, bTemp );
-    Cudd_RecursiveDeref( dd, bCubeNs );
-
-    // get the number of I and CS variables to be quantified
-    nVarsTotal = Cudd_SupportSize( dd, bSupp );
-
-    // start the variables
-    pVars = ABC_ALLOC( Bbr_ImageVar_t *, dd->size );
-    memset( pVars, 0, sizeof(Bbr_ImageVar_t *) * dd->size );
-    // create structures for each variable
-    for ( bSuppTemp = bSupp; bSuppTemp != b1; bSuppTemp = cuddT(bSuppTemp) )
-    {
-        iVar = bSuppTemp->index;
-        pVars[iVar] = ABC_ALLOC( Bbr_ImageVar_t, 1 );
-        pVars[iVar]->iNum = iVar;
-        // collect all the parts this var belongs to
-        Counter = 0;
-        bParts = b1; Cudd_Ref( bParts );
-        for ( p = 0; p < nParts; p++ )
-            if ( Cudd_bddLeq( dd, pParts[p]->bSupp, dd->vars[bSuppTemp->index] ) )
-            {
-                bParts = Cudd_bddAnd( dd, bTemp = bParts, dd->vars[p] );  Cudd_Ref( bParts );
-                Cudd_RecursiveDeref( dd, bTemp );
-                Counter++;
-            }
-        pVars[iVar]->bParts = bParts; // takes ref
-        pVars[iVar]->nParts = Counter;
-    }
-    Cudd_RecursiveDeref( dd, bSupp );
-    return pVars;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Creates variables.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Bbr_ImageNode_t ** Bbr_CreateNodes( DdManager * dd, 
-    int nParts, Bbr_ImagePart_t ** pParts, 
-    int nVars,  Bbr_ImageVar_t ** pVars )
-{
-    Bbr_ImageNode_t ** pNodes;
-    Bbr_ImageNode_t * pNode;
-    DdNode * bTemp;
-    int i, v, iPart;
-/*
-    DdManager *         dd;       // the manager 
-    DdNode *            bCube;    // the cube to quantify
-    DdNode *            bImage;   // the partial image
-    Bbr_ImageNode_t * pNode1;   // the first branch
-    Bbr_ImageNode_t * pNode2;   // the second branch
-    Bbr_ImagePart_t * pPart;    // the partition (temporary)
-*/
-    // start the partitions
-    pNodes = ABC_ALLOC( Bbr_ImageNode_t *, nParts );
-    // create structures for each leaf nodes
-    for ( i = 0; i < nParts; i++ )
-    {
-        pNodes[i] = ABC_ALLOC( Bbr_ImageNode_t, 1 );
-        memset( pNodes[i], 0, sizeof(Bbr_ImageNode_t) );
-        pNodes[i]->dd    = dd;
-        pNodes[i]->pPart = pParts[i];
-    }
-    // find the quantification cubes for each leaf node
-    for ( v = 0; v < nVars; v++ )
-    {
-        if ( pVars[v] == NULL )
-            continue;
-        assert( pVars[v]->nParts > 0 );
-        if ( pVars[v]->nParts > 1 )
-            continue;
-        iPart = pVars[v]->bParts->index;
-        if ( pNodes[iPart]->bCube == NULL )
-        {
-            pNodes[iPart]->bCube = dd->vars[v];   
-            Cudd_Ref( dd->vars[v] );
-        }
-        else
-        {
-            pNodes[iPart]->bCube = Cudd_bddAnd( dd, bTemp = pNodes[iPart]->bCube, dd->vars[v] );  
-            Cudd_Ref( pNodes[iPart]->bCube );
-            Cudd_RecursiveDeref( dd, bTemp );
-        }
-        // remove these  variables
-        Cudd_RecursiveDeref( dd, pVars[v]->bParts );
-        ABC_FREE( pVars[v] );
-    }
-
-    // assign the leaf node images
-    for ( i = 0; i < nParts; i++ )
-    {
-        pNode = pNodes[i];
-        if ( pNode->bCube )
-        {
-            // update the partition
-            pParts[i]->bFunc = Cudd_bddExistAbstract( dd, bTemp = pParts[i]->bFunc, pNode->bCube );
-            Cudd_Ref( pParts[i]->bFunc );
-            Cudd_RecursiveDeref( dd, bTemp );
-            // update the support the partition
-            pParts[i]->bSupp = Cudd_bddExistAbstract( dd, bTemp = pParts[i]->bSupp, pNode->bCube ); 
-            Cudd_Ref( pParts[i]->bSupp );
-            Cudd_RecursiveDeref( dd, bTemp );
-            // update the numbers
-            pParts[i]->nSupp  = Cudd_SupportSize( dd, pParts[i]->bSupp );
-            pParts[i]->nNodes = Cudd_DagSize( pParts[i]->bFunc );
-            // get rid of the cube
-            // save the last (care set) quantification cube
-            if ( i < nParts - 1 )
-            {
-                Cudd_RecursiveDeref( dd, pNode->bCube );
-                pNode->bCube = NULL;
-            }
-        }
-        // copy the function
-        pNode->bImage = pParts[i]->bFunc;   Cudd_Ref( pNode->bImage );
-    }
-/*
-    for ( i = 0; i < nParts; i++ )
-    {
-        pNode = pNodes[i];
-ABC_PRB( dd, pNode->bCube );
-ABC_PRB( dd, pNode->pPart->bFunc );
-ABC_PRB( dd, pNode->pPart->bSupp );
-printf( "\n" );
-    }
-*/
-    return pNodes;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Delete the partitions from the nodes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Bbr_DeleteParts_rec( Bbr_ImageNode_t * pNode )
-{
-    Bbr_ImagePart_t * pPart;
-    if ( pNode->pNode1 )
-        Bbr_DeleteParts_rec( pNode->pNode1 );
-    if ( pNode->pNode2 )
-        Bbr_DeleteParts_rec( pNode->pNode2 );
-    pPart = pNode->pPart;
-    Cudd_RecursiveDeref( pNode->dd, pPart->bFunc );
-    Cudd_RecursiveDeref( pNode->dd, pPart->bSupp );
-    ABC_FREE( pNode->pPart );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Delete the partitions from the nodes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Bbr_bddImageTreeDelete_rec( Bbr_ImageNode_t * pNode )
-{
-    if ( pNode->pNode1 )
-        Bbr_bddImageTreeDelete_rec( pNode->pNode1 );
-    if ( pNode->pNode2 )
-        Bbr_bddImageTreeDelete_rec( pNode->pNode2 );
-    if ( pNode->bCube )
-        Cudd_RecursiveDeref( pNode->dd, pNode->bCube );
-    if ( pNode->bImage )
-        Cudd_RecursiveDeref( pNode->dd, pNode->bImage );
-    assert( pNode->pPart == NULL );
-    ABC_FREE( pNode );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Recompute the image.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Bbr_bddImageCompute_rec( Bbr_ImageTree_t * pTree, Bbr_ImageNode_t * pNode )
-{
-    DdManager * dd = pNode->dd;
-    DdNode * bTemp;
-    int nNodes;
-
-    // trivial case
-    if ( pNode->pNode1 == NULL )
-    {
-        if ( pNode->bCube )
-        {
-            pNode->bImage = Cudd_bddExistAbstract( dd, bTemp = pNode->bImage, pNode->bCube ); 
-            Cudd_Ref( pNode->bImage );
-            Cudd_RecursiveDeref( dd, bTemp );
-        }
-        return 1;
-    }
-
-    // compute the children
-    if ( pNode->pNode1 )
-        if ( !Bbr_bddImageCompute_rec( pTree, pNode->pNode1 ) )
-            return 0;
-    if ( pNode->pNode2 )
-        if ( !Bbr_bddImageCompute_rec( pTree, pNode->pNode2 ) )
-            return 0;
-
-    // clean the old image
-    if ( pNode->bImage )
-        Cudd_RecursiveDeref( dd, pNode->bImage );
-    pNode->bImage = NULL;
-
-    // compute the new image
-    if ( pNode->bCube )
-        pNode->bImage = Cudd_bddAndAbstract( dd, 
-            pNode->pNode1->bImage, pNode->pNode2->bImage, pNode->bCube );
-    else
-        pNode->bImage = Cudd_bddAnd( dd, pNode->pNode1->bImage, pNode->pNode2->bImage );
-    Cudd_Ref( pNode->bImage );
-
-    if ( pTree->fVerbose )
-    {
-        nNodes = Cudd_DagSize( pNode->bImage );
-        if ( pTree->nNodesMax < nNodes )
-            pTree->nNodesMax = nNodes;
-    }
-    if ( dd->keys-dd->dead > (unsigned)pTree->nBddMax )
-        return 0;
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Builds the tree.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Bbr_BuildTreeNode( DdManager * dd, 
-    int nNodes, Bbr_ImageNode_t ** pNodes, 
-    int nVars,  Bbr_ImageVar_t ** pVars, int * pfStop, int nBddMax )
-{
-    Bbr_ImageNode_t * pNode1, * pNode2;
-    Bbr_ImageVar_t * pVar;
-    Bbr_ImageNode_t * pNode;
-    DdNode * bCube, * bTemp, * bSuppTemp;//, * bParts;
-    int iNode1, iNode2;
-    int iVarBest, nSupp, v;
-
-    // find the best variable
-    iVarBest = Bbr_FindBestVariable( dd, nNodes, pNodes, nVars, pVars );
-    if ( iVarBest == -1 )
-        return 0;
-/*
-for ( v = 0; v < nVars; v++ )
-{
-    DdNode * bSupp;
-    if ( pVars[v] == NULL )
-        continue;
-    printf( "%3d :", v );
-    printf( "%3d ", pVars[v]->nParts );
-    bSupp = Cudd_Support( dd, pVars[v]->bParts );  Cudd_Ref( bSupp );
-    Bbr_bddPrint( dd, bSupp ); printf( "\n" );
-    Cudd_RecursiveDeref( dd, bSupp );
-}
-*/
-    pVar = pVars[iVarBest];
-
-    // this var cannot appear in one partition only
-    nSupp = Cudd_SupportSize( dd, pVar->bParts );
-    assert( nSupp == pVar->nParts );
-    assert( nSupp != 1 );
-//printf( "var = %d  supp = %d\n\n", iVarBest, nSupp );
-
-    // if it appears in only two partitions, quantify it
-    if ( pVar->nParts == 2 )
-    {
-        // get the nodes
-        iNode1 = pVar->bParts->index;
-        iNode2 = cuddT(pVar->bParts)->index;
-        pNode1 = pNodes[iNode1];
-        pNode2 = pNodes[iNode2];
-
-        // get the quantification cube
-        bCube = dd->vars[pVar->iNum];    Cudd_Ref( bCube );
-        // add the variables that appear only in these partitions
-        for ( v = 0; v < nVars; v++ )
-            if ( pVars[v] && v != iVarBest && pVars[v]->bParts == pVars[iVarBest]->bParts )
-            {
-                // add this var
-                bCube = Cudd_bddAnd( dd, bTemp = bCube, dd->vars[pVars[v]->iNum] );   Cudd_Ref( bCube );
-                Cudd_RecursiveDeref( dd, bTemp );
-                // clean this var
-                Cudd_RecursiveDeref( dd, pVars[v]->bParts );
-                ABC_FREE( pVars[v] );
-            }
-        // clean the best var
-        Cudd_RecursiveDeref( dd, pVars[iVarBest]->bParts );
-        ABC_FREE( pVars[iVarBest] );
-
-        // combines two nodes
-        pNode = Bbr_CombineTwoNodes( dd, bCube, pNode1, pNode2 );
-        Cudd_RecursiveDeref( dd, bCube );
-    }
-    else // if ( pVar->nParts > 2 )
-    {
-        // find two smallest BDDs that have this var
-        Bbr_FindBestPartitions( dd, pVar->bParts, nNodes, pNodes, &iNode1, &iNode2 );
-        pNode1 = pNodes[iNode1];
-        pNode2 = pNodes[iNode2];
-//printf( "smallest bdds with this var: %d %d\n", iNode1, iNode2 );
-/*
-        // it is not possible that a var appears only in these two
-        // otherwise, it would have a different cost
-        bParts = Cudd_bddAnd( dd, dd->vars[iNode1], dd->vars[iNode2] ); Cudd_Ref( bParts );
-        for ( v = 0; v < nVars; v++ )
-            if ( pVars[v] && pVars[v]->bParts == bParts )
-                assert( 0 );
-        Cudd_RecursiveDeref( dd, bParts );
-*/
-        // combines two nodes
-        pNode = Bbr_CombineTwoNodes( dd, b1, pNode1, pNode2 );
-    }
-
-    // clean the old nodes
-    pNodes[iNode1] = pNode;
-    pNodes[iNode2] = NULL;
-//printf( "Removing node %d (leaving node %d)\n", iNode2, iNode1 );
-    
-    // update the variables that appear in pNode[iNode2]
-    for ( bSuppTemp = pNode2->pPart->bSupp; bSuppTemp != b1; bSuppTemp = cuddT(bSuppTemp) )
-    {
-        pVar = pVars[bSuppTemp->index];
-        if ( pVar == NULL ) // this variable is not be quantified
-            continue;
-        // quantify this var
-        assert( Cudd_bddLeq( dd, pVar->bParts, dd->vars[iNode2] ) );
-        pVar->bParts = Cudd_bddExistAbstract( dd, bTemp = pVar->bParts, dd->vars[iNode2] ); Cudd_Ref( pVar->bParts );
-        Cudd_RecursiveDeref( dd, bTemp );
-        // add the new var
-        pVar->bParts = Cudd_bddAnd( dd, bTemp = pVar->bParts, dd->vars[iNode1] ); Cudd_Ref( pVar->bParts );
-        Cudd_RecursiveDeref( dd, bTemp );
-        // update the score
-        pVar->nParts = Cudd_SupportSize( dd, pVar->bParts );
-    }
-
-    *pfStop = 0;
-    if ( dd->keys-dd->dead > (unsigned)nBddMax )
-    {
-        *pfStop = 1;
-        return 0;
-    }
-    return 1;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Merges the nodes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Bbr_ImageNode_t * Bbr_MergeTopNodes(
-    DdManager * dd, int nNodes, Bbr_ImageNode_t ** pNodes )
-{
-    Bbr_ImageNode_t * pNode;
-    int n1 = -1, n2 = -1, n;
-
-    // find the first and the second non-empty spots
-    for ( n = 0; n < nNodes; n++ )
-        if ( pNodes[n] )
-        {
-            if ( n1 == -1 )
-                n1 = n;
-            else if ( n2 == -1 )
-            {
-                n2 = n;
-                break;
-            }
-        }
-    assert( n1 != -1 );
-    // check the situation when only one such node is detected
-    if ( n2 == -1 )
-    {
-        // save the node
-        pNode = pNodes[n1];
-        // clean the node
-        pNodes[n1] = NULL;
-        return pNode;
-    }
-  
-    // combines two nodes
-    pNode = Bbr_CombineTwoNodes( dd, b1, pNodes[n1], pNodes[n2] );
-
-    // clean the old nodes
-    pNodes[n1] = pNode;
-    pNodes[n2] = NULL;
-    return NULL;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Merges two nodes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Bbr_ImageNode_t * Bbr_CombineTwoNodes( DdManager * dd, DdNode * bCube,
-    Bbr_ImageNode_t * pNode1, Bbr_ImageNode_t * pNode2 )
-{
-    Bbr_ImageNode_t * pNode;
-    Bbr_ImagePart_t * pPart;
-
-    // create a new partition
-    pPart = ABC_ALLOC( Bbr_ImagePart_t, 1 );
-    memset( pPart, 0, sizeof(Bbr_ImagePart_t) );
-    // create the function
-    pPart->bFunc = Cudd_bddAndAbstract( dd, pNode1->pPart->bFunc, pNode2->pPart->bFunc, bCube );
-    Cudd_Ref( pPart->bFunc );
-    // update the support the partition
-    pPart->bSupp = Cudd_bddAndAbstract( dd, pNode1->pPart->bSupp, pNode2->pPart->bSupp, bCube );
-    Cudd_Ref( pPart->bSupp );
-    // update the numbers
-    pPart->nSupp  = Cudd_SupportSize( dd, pPart->bSupp );
-    pPart->nNodes = Cudd_DagSize( pPart->bFunc );
-    pPart->iPart = -1;
-/*
-ABC_PRB( dd, pNode1->pPart->bSupp );
-ABC_PRB( dd, pNode2->pPart->bSupp );
-ABC_PRB( dd, pPart->bSupp );
-*/
-    // create a new node
-    pNode = ABC_ALLOC( Bbr_ImageNode_t, 1 );
-    memset( pNode, 0, sizeof(Bbr_ImageNode_t) );
-    pNode->dd     = dd;
-    pNode->pPart  = pPart;
-    pNode->pNode1 = pNode1;
-    pNode->pNode2 = pNode2;
-    // compute the image
-    pNode->bImage = Cudd_bddAndAbstract( dd, pNode1->bImage, pNode2->bImage, bCube ); 
-    Cudd_Ref( pNode->bImage );
-    // save the cube
-    if ( bCube != b1 )
-    {
-        pNode->bCube = bCube;   Cudd_Ref( bCube );
-    }
-    return pNode;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Computes the best variable.]
-
-  Description [The variables is the best if the sum of squares of the
-  BDD sizes of the partitions, in which it participates, is the minimum.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Bbr_FindBestVariable( DdManager * dd,
-    int nNodes, Bbr_ImageNode_t ** pNodes, 
-    int nVars,  Bbr_ImageVar_t ** pVars )
-{
-    DdNode * bTemp;
-    int iVarBest, v;
-    double CostBest, CostCur;
-
-    CostBest = 100000000000000.0;
-    iVarBest = -1;
-
-    // check if there are two-variable partitions
-    for ( v = 0; v < nVars; v++ )
-        if ( pVars[v] && pVars[v]->nParts == 2 )
-        {
-            CostCur = 0;
-            for ( bTemp = pVars[v]->bParts; bTemp != b1; bTemp = cuddT(bTemp) )
-                CostCur += pNodes[bTemp->index]->pPart->nNodes * 
-                           pNodes[bTemp->index]->pPart->nNodes;
-            if ( CostBest > CostCur )
-            {
-                CostBest = CostCur;
-                iVarBest = v;
-            }
-        }
-    if ( iVarBest >= 0 )
-        return iVarBest;
-
-    // find other partition
-    for ( v = 0; v < nVars; v++ )
-        if ( pVars[v] )
-        {
-            assert( pVars[v]->nParts > 1 );
-            CostCur = 0;
-            for ( bTemp = pVars[v]->bParts; bTemp != b1; bTemp = cuddT(bTemp) )
-                CostCur += pNodes[bTemp->index]->pPart->nNodes * 
-                           pNodes[bTemp->index]->pPart->nNodes;
-            if ( CostBest > CostCur )
-            {
-                CostBest = CostCur;
-                iVarBest = v;
-            }
-        }
-    return iVarBest;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Computes two smallest partions that have this var.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Bbr_FindBestPartitions( DdManager * dd, DdNode * bParts, 
-    int nNodes, Bbr_ImageNode_t ** pNodes, 
-    int * piNode1, int * piNode2 )
-{
-    DdNode * bTemp;
-    int iPart1, iPart2;
-    int CostMin1, CostMin2, Cost;
-
-    // go through the partitions
-    iPart1 = iPart2 = -1;
-    CostMin1 = CostMin2 = 1000000;
-    for ( bTemp = bParts; bTemp != b1; bTemp = cuddT(bTemp) )
-    {
-        Cost = pNodes[bTemp->index]->pPart->nNodes;
-        if ( CostMin1 > Cost )
-        {
-            CostMin2 = CostMin1;    iPart2 = iPart1;
-            CostMin1 = Cost;        iPart1 = bTemp->index;
-        }
-        else if ( CostMin2 > Cost )
-        {
-            CostMin2 = Cost;        iPart2 = bTemp->index;
-        }
-    }
-
-    *piNode1 = iPart1;
-    *piNode2 = iPart2;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Prints the latch dependency matrix.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Bbr_bddImagePrintLatchDependency( 
-    DdManager * dd, DdNode * bCare, // the care set
-    int nParts, DdNode ** pbParts,  // the partitions for image computation
-    int nVars, DdNode ** pbVars )   // the NS and parameter variables (not quantified!)
-{
-    int i;
-    DdNode * bVarsCs, * bVarsNs;
-
-    bVarsCs = Cudd_Support( dd, bCare );                       Cudd_Ref( bVarsCs );
-    bVarsNs = Cudd_bddComputeCube( dd, pbVars, NULL, nVars );  Cudd_Ref( bVarsNs );
-
-    printf( "The latch dependency matrix:\n" );
-    printf( "Partitions = %d   Variables: total = %d  non-quantifiable = %d\n",
-        nParts, dd->size, nVars );
-    printf( "     : " );
-    for ( i = 0; i < dd->size; i++ )
-        printf( "%d", i % 10 );
-    printf( "\n" );
-
-    for ( i = 0; i < nParts; i++ )
-        Bbr_bddImagePrintLatchDependencyOne( dd, pbParts[i], bVarsCs, bVarsNs, i );
-    Bbr_bddImagePrintLatchDependencyOne( dd, bCare, bVarsCs, bVarsNs, nParts );
-
-    Cudd_RecursiveDeref( dd, bVarsCs );
-    Cudd_RecursiveDeref( dd, bVarsNs );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Prints one row of the latch dependency matrix.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Bbr_bddImagePrintLatchDependencyOne(
-    DdManager * dd, DdNode * bFunc,      // the function
-    DdNode * bVarsCs, DdNode * bVarsNs,  // the current/next state vars
-    int iPart )
-{
-    DdNode * bSupport;
-    int v;
-    bSupport = Cudd_Support( dd, bFunc );  Cudd_Ref( bSupport );
-    printf( " %3d : ", iPart );
-    for ( v = 0; v < dd->size; v++ )
-    {
-        if ( Cudd_bddLeq( dd, bSupport, dd->vars[v] ) )
-        {
-            if ( Cudd_bddLeq( dd, bVarsCs, dd->vars[v] ) )
-                printf( "c" );
-            else if ( Cudd_bddLeq( dd, bVarsNs, dd->vars[v] ) ) 
-                printf( "n" );
-            else
-                printf( "i" );
-        }
-        else
-            printf( "." );
-    }
-    printf( "\n" );
-    Cudd_RecursiveDeref( dd, bSupport );
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Prints the tree for quenstification scheduling.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Bbr_bddImagePrintTree( Bbr_ImageTree_t * pTree )
-{
-    printf( "The quantification scheduling tree:\n" );
-    Bbr_bddImagePrintTree_rec( pTree->pRoot, 1 );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Prints the tree for quenstification scheduling.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Bbr_bddImagePrintTree_rec( Bbr_ImageNode_t * pNode, int Offset )
-{
-    DdNode * Cube;
-    int i;
-
-    Cube = pNode->bCube;
-
-    if ( pNode->pNode1 == NULL )
-    {
-        printf( "<%d> ", pNode->pPart->iPart );
-        if ( Cube != NULL )
-        {
-            ABC_PRB( pNode->dd, Cube );
-        }
-        else
-            printf( "\n" );
-        return;
-    }
-
-    printf( "<*> " );
-    if ( Cube != NULL )
-    {
-        ABC_PRB( pNode->dd, Cube );
-    }
-    else
-        printf( "\n" );
-
-    for ( i = 0; i < Offset; i++ )
-        printf( "    " );
-    Bbr_bddImagePrintTree_rec( pNode->pNode1, Offset + 1 );
-
-    for ( i = 0; i < Offset; i++ )
-        printf( "    " );
-    Bbr_bddImagePrintTree_rec( pNode->pNode2, Offset + 1 );
-}
-
-/**Function********************************************************************
-
-  Synopsis    [Computes the positive polarty cube composed of the first vars in the array.]
-
-  Description []
-
-  SideEffects []
-
-  SeeAlso     []
-
-******************************************************************************/
-DdNode * Bbr_bddComputeCube( DdManager * dd, DdNode ** bXVars, int nVars )
-{
-    DdNode * bRes;
-    DdNode * bTemp;
-    int i;
-
-    bRes = b1; Cudd_Ref( bRes );
-    for ( i = 0; i < nVars; i++ )
-    {
-        bRes = Cudd_bddAnd( dd, bTemp = bRes, bXVars[i] );  Cudd_Ref( bRes );
-        Cudd_RecursiveDeref( dd, bTemp );
-    }
-
-    Cudd_Deref( bRes );
-    return bRes;
-}
-
-
-
-
-
-struct Bbr_ImageTree2_t_
-{
-    DdManager * dd;
-    DdNode *    bRel;
-    DdNode *    bCube;
-    DdNode *    bImage;
-};
-
-/**Function*************************************************************
-
-  Synopsis    [Starts the monolithic image computation.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Bbr_ImageTree2_t * Bbr_bddImageStart2( 
-    DdManager * dd, DdNode * bCare,
-    int nParts, DdNode ** pbParts,
-    int nVars, DdNode ** pbVars, int fVerbose )
-{
-    Bbr_ImageTree2_t * pTree;
-    DdNode * bCubeAll, * bCubeNot, * bTemp;
-    int i;
-
-    pTree = ABC_ALLOC( Bbr_ImageTree2_t, 1 );
-    pTree->dd = dd;
-    pTree->bImage = NULL;
-
-    bCubeAll = Bbr_bddComputeCube( dd, dd->vars, dd->size );      Cudd_Ref( bCubeAll );
-    bCubeNot = Bbr_bddComputeCube( dd, pbVars,   nVars );         Cudd_Ref( bCubeNot );
-    pTree->bCube = Cudd_bddExistAbstract( dd, bCubeAll, bCubeNot ); Cudd_Ref( pTree->bCube );
-    Cudd_RecursiveDeref( dd, bCubeAll );
-    Cudd_RecursiveDeref( dd, bCubeNot );
-
-    // derive the monolithic relation
-    pTree->bRel = b1;   Cudd_Ref( pTree->bRel );
-    for ( i = 0; i < nParts; i++ )
-    {
-        pTree->bRel = Cudd_bddAnd( dd, bTemp = pTree->bRel, pbParts[i] ); Cudd_Ref( pTree->bRel );
-        Cudd_RecursiveDeref( dd, bTemp );
-    }
-    Bbr_bddImageCompute2( pTree, bCare );
-    return pTree;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Bbr_bddImageCompute2( Bbr_ImageTree2_t * pTree, DdNode * bCare )
-{
-    if ( pTree->bImage )
-        Cudd_RecursiveDeref( pTree->dd, pTree->bImage );
-    pTree->bImage = Cudd_bddAndAbstract( pTree->dd, pTree->bRel, bCare, pTree->bCube ); 
-    Cudd_Ref( pTree->bImage );
-    return pTree->bImage;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Bbr_bddImageTreeDelete2( Bbr_ImageTree2_t * pTree )
-{
-    if ( pTree->bRel )
-        Cudd_RecursiveDeref( pTree->dd, pTree->bRel );
-    if ( pTree->bCube )
-        Cudd_RecursiveDeref( pTree->dd, pTree->bCube );
-    if ( pTree->bImage )
-        Cudd_RecursiveDeref( pTree->dd, pTree->bImage );
-    ABC_FREE( pTree );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns the previously computed image.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Bbr_bddImageRead2( Bbr_ImageTree2_t * pTree )
-{
-    return pTree->bImage;
-}
-
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/bbr/bbrNtbdd.c b/src/proof/bbr/bbrNtbdd.c
deleted file mode 100644
index f61c3d73..00000000
--- a/src/proof/bbr/bbrNtbdd.c
+++ /dev/null
@@ -1,218 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [bbrNtbdd.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD-based reachability analysis.]
-
-  Synopsis    [Procedures to construct global BDDs for the network.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: bbrNtbdd.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "bbr.h"
-//#include "bar.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-typedef char ProgressBar;
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-static inline void     Aig_ObjSetGlobalBdd( Aig_Obj_t * pObj, DdNode * bFunc )   { pObj->pData = bFunc; }
-static inline void     Aig_ObjCleanGlobalBdd( DdManager * dd, Aig_Obj_t * pObj ) { Cudd_RecursiveDeref( dd, (DdNode *)pObj->pData ); pObj->pData = NULL; }
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Derives the global BDD for one AIG node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Bbr_NodeGlobalBdds_rec( DdManager * dd, Aig_Obj_t * pNode, int nBddSizeMax, int fDropInternal, ProgressBar * pProgress, int * pCounter, int fVerbose )
-{
-    DdNode * bFunc, * bFunc0, * bFunc1;
-    assert( !Aig_IsComplement(pNode) );
-    if ( Cudd_ReadKeys(dd)-Cudd_ReadDead(dd) > (unsigned)nBddSizeMax )
-    {
-//        Extra_ProgressBarStop( pProgress );
-        if ( fVerbose )
-        printf( "The number of live nodes reached %d.\n", nBddSizeMax );
-        fflush( stdout );
-        return NULL;
-    }
-    // if the result is available return
-    if ( Aig_ObjGlobalBdd(pNode) == NULL )
-    {
-        // compute the result for both branches
-        bFunc0 = Bbr_NodeGlobalBdds_rec( dd, Aig_ObjFanin0(pNode), nBddSizeMax, fDropInternal, pProgress, pCounter, fVerbose ); 
-        if ( bFunc0 == NULL )
-            return NULL;
-        Cudd_Ref( bFunc0 );
-        bFunc1 = Bbr_NodeGlobalBdds_rec( dd, Aig_ObjFanin1(pNode), nBddSizeMax, fDropInternal, pProgress, pCounter, fVerbose ); 
-        if ( bFunc1 == NULL )
-            return NULL;
-        Cudd_Ref( bFunc1 );
-        bFunc0 = Cudd_NotCond( bFunc0, Aig_ObjFaninC0(pNode) );
-        bFunc1 = Cudd_NotCond( bFunc1, Aig_ObjFaninC1(pNode) );
-        // get the final result
-        bFunc = Cudd_bddAnd( dd, bFunc0, bFunc1 );   Cudd_Ref( bFunc );
-        Cudd_RecursiveDeref( dd, bFunc0 );
-        Cudd_RecursiveDeref( dd, bFunc1 );
-        // add the number of used nodes
-        (*pCounter)++;
-        // set the result
-        assert( Aig_ObjGlobalBdd(pNode) == NULL );
-        Aig_ObjSetGlobalBdd( pNode, bFunc );
-        // increment the progress bar
-//        if ( pProgress )
-//            Extra_ProgressBarUpdate( pProgress, *pCounter, NULL );
-    }
-    // prepare the return value
-    bFunc = Aig_ObjGlobalBdd(pNode);
-    // dereference BDD at the node
-    if ( --pNode->nRefs == 0 && fDropInternal )
-    {
-        Cudd_Deref( bFunc );
-        Aig_ObjSetGlobalBdd( pNode, NULL );
-    }
-    return bFunc;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Frees the global BDDs of the network.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Aig_ManFreeGlobalBdds( Aig_Man_t * p, DdManager * dd ) 
-{ 
-    Aig_Obj_t * pObj;
-    int i;
-    Aig_ManForEachObj( p, pObj, i )
-        if ( Aig_ObjGlobalBdd(pObj) )
-            Aig_ObjCleanGlobalBdd( dd, pObj );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns the shared size of global BDDs of the COs.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Aig_ManSizeOfGlobalBdds( Aig_Man_t * p ) 
-{
-    Vec_Ptr_t * vFuncsGlob;
-    Aig_Obj_t * pObj;
-    int RetValue, i;
-    // complement the global functions
-    vFuncsGlob = Vec_PtrAlloc( Aig_ManCoNum(p) );
-    Aig_ManForEachCo( p, pObj, i )
-        Vec_PtrPush( vFuncsGlob, Aig_ObjGlobalBdd(pObj) );
-    RetValue = Cudd_SharingSize( (DdNode **)Vec_PtrArray(vFuncsGlob), Vec_PtrSize(vFuncsGlob) );
-    Vec_PtrFree( vFuncsGlob );
-    return RetValue;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Recursively computes global BDDs for the AIG in the manager.]
-
-  Description [On exit, BDDs are stored in the pNode->pData fields.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdManager * Aig_ManComputeGlobalBdds( Aig_Man_t * p, int nBddSizeMax, int fDropInternal, int fReorder, int fVerbose )
-{
-    ProgressBar * pProgress = NULL;
-    Aig_Obj_t * pObj;
-    DdManager * dd;
-    DdNode * bFunc;
-    int i, Counter;
-    // start the manager
-    dd = Cudd_Init( Aig_ManCiNum(p), 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
-    // set reordering
-    if ( fReorder )
-        Cudd_AutodynEnable( dd, CUDD_REORDER_SYMM_SIFT );
-    // prepare to construct global BDDs
-    Aig_ManCleanData( p );
-    // assign the constant node BDD
-    Aig_ObjSetGlobalBdd( Aig_ManConst1(p), dd->one );   Cudd_Ref( dd->one );
-    // set the elementary variables
-    Aig_ManForEachCi( p, pObj, i )
-    {
-        Aig_ObjSetGlobalBdd( pObj, dd->vars[i] );  Cudd_Ref( dd->vars[i] );
-    }
-
-    // collect the global functions of the COs
-    Counter = 0;
-    // construct the BDDs
-//    pProgress = Extra_ProgressBarStart( stdout, Aig_ManNodeNum(p) );
-    Aig_ManForEachCo( p, pObj, i )
-    {
-        bFunc = Bbr_NodeGlobalBdds_rec( dd, Aig_ObjFanin0(pObj), nBddSizeMax, fDropInternal, pProgress, &Counter, fVerbose );
-        if ( bFunc == NULL )
-        {
-            if ( fVerbose )
-            printf( "Constructing global BDDs is aborted.\n" );
-            Aig_ManFreeGlobalBdds( p, dd );
-            Cudd_Quit( dd ); 
-            // reset references
-            Aig_ManResetRefs( p );
-            return NULL;
-        }
-        bFunc = Cudd_NotCond( bFunc, Aig_ObjFaninC0(pObj) );  Cudd_Ref( bFunc ); 
-        Aig_ObjSetGlobalBdd( pObj, bFunc );
-    }
-//    Extra_ProgressBarStop( pProgress );
-    // reset references
-    Aig_ManResetRefs( p );
-    // reorder one more time
-    if ( fReorder )
-    {
-        Cudd_ReduceHeap( dd, CUDD_REORDER_SYMM_SIFT, 1 );
-        Cudd_AutodynDisable( dd );
-    }
-//    Cudd_PrintInfo( dd, stdout );
-    return dd;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/bbr/bbrReach.c b/src/proof/bbr/bbrReach.c
deleted file mode 100644
index b5125ec7..00000000
--- a/src/proof/bbr/bbrReach.c
+++ /dev/null
@@ -1,615 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [bbrReach.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD-based reachability analysis.]
-
-  Synopsis    [Procedures to perform reachability analysis.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: bbrReach.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "bbr.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-extern Abc_Cex_t * Aig_ManVerifyUsingBddsCountExample( Aig_Man_t * p, DdManager * dd, 
-    DdNode ** pbParts, Vec_Ptr_t * vOnionRings, DdNode * bCubeFirst, 
-    int iOutput, int fVerbose, int fSilent );
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [This procedure sets default resynthesis parameters.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Bbr_ManSetDefaultParams( Saig_ParBbr_t * p )
-{
-    memset( p, 0, sizeof(Saig_ParBbr_t) );
-    p->TimeLimit     =     0;
-    p->nBddMax       = 50000;
-    p->nIterMax      =  1000;
-    p->fPartition    =     1;
-    p->fReorder      =     1;
-    p->fReorderImage =     1;
-    p->fVerbose      =     0;
-    p->fSilent       =     0;
-    p->iFrame        =    -1;
-}
-
-/**Function********************************************************************
-
-  Synopsis    [Performs the reordering-sensitive step of Extra_bddMove().]
-
-  Description []
-
-  SideEffects []
-
-  SeeAlso     []
-
-******************************************************************************/
-DdNode * Bbr_bddComputeRangeCube( DdManager * dd, int iStart, int iStop )
-{
-    DdNode * bTemp, * bProd;
-    int i;
-    assert( iStart <= iStop );
-    assert( iStart >= 0 && iStart <= dd->size );
-    assert( iStop >= 0  && iStop  <= dd->size );
-    bProd = (dd)->one;         Cudd_Ref( bProd );
-    for ( i = iStart; i < iStop; i++ )
-    {
-        bProd = Cudd_bddAnd( dd, bTemp = bProd, dd->vars[i] );      Cudd_Ref( bProd );
-        Cudd_RecursiveDeref( dd, bTemp ); 
-    }
-    Cudd_Deref( bProd );
-    return bProd;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Bbr_StopManager( DdManager * dd )
-{
-    int RetValue;
-    // check for remaining references in the package
-    RetValue = Cudd_CheckZeroRef( dd );
-    if ( RetValue > 0 )
-        printf( "\nThe number of referenced nodes = %d\n\n", RetValue );
-//  Cudd_PrintInfo( dd, stdout );
-    Cudd_Quit( dd );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Computes the initial state and sets up the variable map.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Aig_ManInitStateVarMap( DdManager * dd, Aig_Man_t * p, int fVerbose )
-{
-    DdNode ** pbVarsX, ** pbVarsY;
-    DdNode * bTemp, * bProd;
-    Aig_Obj_t * pLatch;
-    int i;
-
-    // set the variable mapping for Cudd_bddVarMap()
-    pbVarsX = ABC_ALLOC( DdNode *, dd->size );
-    pbVarsY = ABC_ALLOC( DdNode *, dd->size );
-    bProd = (dd)->one;         Cudd_Ref( bProd );
-    Saig_ManForEachLo( p, pLatch, i )
-    {
-        pbVarsX[i] = dd->vars[ Saig_ManPiNum(p) + i ];
-        pbVarsY[i] = dd->vars[ Saig_ManCiNum(p) + i ];
-        // get the initial value of the latch
-        bProd = Cudd_bddAnd( dd, bTemp = bProd, Cudd_Not(pbVarsX[i]) );      Cudd_Ref( bProd );
-        Cudd_RecursiveDeref( dd, bTemp ); 
-    }
-    Cudd_SetVarMap( dd, pbVarsX, pbVarsY, Saig_ManRegNum(p) );
-    ABC_FREE( pbVarsX );
-    ABC_FREE( pbVarsY );
-
-    Cudd_Deref( bProd );
-    return bProd;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Collects the array of output BDDs.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode ** Aig_ManCreateOutputs( DdManager * dd, Aig_Man_t * p )
-{
-    DdNode ** pbOutputs;
-    Aig_Obj_t * pNode;
-    int i;
-    // compute the transition relation
-    pbOutputs = ABC_ALLOC( DdNode *, Saig_ManPoNum(p) );
-    Saig_ManForEachPo( p, pNode, i )
-    {
-        pbOutputs[i] = Aig_ObjGlobalBdd(pNode);  Cudd_Ref( pbOutputs[i] );
-    }
-    return pbOutputs;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Collects the array of partition BDDs.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode ** Aig_ManCreatePartitions( DdManager * dd, Aig_Man_t * p, int fReorder, int fVerbose )
-{
-    DdNode ** pbParts;
-    DdNode * bVar;
-    Aig_Obj_t * pNode;
-    int i;
-
-    // extand the BDD manager to represent NS variables
-    assert( dd->size == Saig_ManCiNum(p) );
-    Cudd_bddIthVar( dd, Saig_ManCiNum(p) + Saig_ManRegNum(p) - 1 );
-
-    // enable reordering
-    if ( fReorder )
-        Cudd_AutodynEnable( dd, CUDD_REORDER_SYMM_SIFT );
-    else
-        Cudd_AutodynDisable( dd );
-
-    // compute the transition relation
-    pbParts = ABC_ALLOC( DdNode *, Saig_ManRegNum(p) );
-    Saig_ManForEachLi( p, pNode, i )
-    {
-        bVar  = Cudd_bddIthVar( dd, Saig_ManCiNum(p) + i );
-        pbParts[i] = Cudd_bddXnor( dd, bVar, Aig_ObjGlobalBdd(pNode) );  Cudd_Ref( pbParts[i] );
-    }
-    // free global BDDs
-    Aig_ManFreeGlobalBdds( p, dd );
-
-    // reorder and disable reordering
-    if ( fReorder )
-    {
-        if ( fVerbose )
-            fprintf( stdout, "BDD nodes in the partitions before reordering %d.\n", Cudd_SharingSize(pbParts,Saig_ManRegNum(p)) );
-        Cudd_ReduceHeap( dd, CUDD_REORDER_SYMM_SIFT, 100 );
-        Cudd_AutodynDisable( dd );
-        if ( fVerbose )
-            fprintf( stdout, "BDD nodes in the partitions after reordering %d.\n", Cudd_SharingSize(pbParts,Saig_ManRegNum(p)) );
-    }
-    return pbParts;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Computes the set of unreachable states.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Aig_ManComputeReachable( DdManager * dd, Aig_Man_t * p, DdNode ** pbParts, DdNode * bInitial, DdNode ** pbOutputs, Saig_ParBbr_t * pPars, int fCheckOutputs )
-{
-    int fInternalReorder = 0;
-    Bbr_ImageTree_t * pTree = NULL; // Suppress "might be used uninitialized"
-    Bbr_ImageTree2_t * pTree2 = NULL; // Supprses "might be used uninitialized"
-    DdNode * bReached, * bCubeCs;
-    DdNode * bCurrent;
-    DdNode * bNext = NULL; // Suppress "might be used uninitialized"
-    DdNode * bTemp;
-    Cudd_ReorderingType method;
-    int i, nIters, nBddSize = 0, status;
-    int nThreshold = 10000;
-    abctime clk = Abc_Clock();
-    Vec_Ptr_t * vOnionRings;
-    int fixedPoint = 0;
-
-    status = Cudd_ReorderingStatus( dd, &method );
-    if ( status )
-        Cudd_AutodynDisable( dd );
-
-    // start the image computation
-    bCubeCs  = Bbr_bddComputeRangeCube( dd, Saig_ManPiNum(p), Saig_ManCiNum(p) );    Cudd_Ref( bCubeCs );
-    if ( pPars->fPartition )
-        pTree = Bbr_bddImageStart( dd, bCubeCs, Saig_ManRegNum(p), pbParts, Saig_ManRegNum(p), dd->vars+Saig_ManCiNum(p), pPars->nBddMax, pPars->fVerbose );
-    else
-        pTree2 = Bbr_bddImageStart2( dd, bCubeCs, Saig_ManRegNum(p), pbParts, Saig_ManRegNum(p), dd->vars+Saig_ManCiNum(p), pPars->fVerbose );
-    Cudd_RecursiveDeref( dd, bCubeCs );
-    if ( pTree == NULL )
-    {
-        if ( !pPars->fSilent )
-            printf( "BDDs blew up during qualitification scheduling.  " );
-        return -1;
-    }
-
-    if ( status )
-        Cudd_AutodynEnable( dd, method );
-
-    // start the onion rings
-    vOnionRings = Vec_PtrAlloc( 1000 );
-
-    // perform reachability analysis
-    bCurrent = bInitial;   Cudd_Ref( bCurrent );
-    bReached = bInitial;   Cudd_Ref( bReached );
-    Vec_PtrPush( vOnionRings, bCurrent );  Cudd_Ref( bCurrent );
-    for ( nIters = 0; nIters < pPars->nIterMax; nIters++ )
-    { 
-        // check the runtime limit
-        if ( pPars->TimeLimit && pPars->TimeLimit <= (Abc_Clock()-clk)/CLOCKS_PER_SEC )
-        {
-            printf( "Reached timeout after image computation (%d seconds).\n",  pPars->TimeLimit );
-            Vec_PtrFree( vOnionRings );
-            // undo the image tree
-            if ( pPars->fPartition )
-                Bbr_bddImageTreeDelete( pTree );
-            else
-                Bbr_bddImageTreeDelete2( pTree2 );
-            pPars->iFrame = nIters - 1;
-            return -1;
-        }
-
-        // compute the next states
-        if ( pPars->fPartition )
-            bNext = Bbr_bddImageCompute( pTree, bCurrent );           
-        else
-            bNext = Bbr_bddImageCompute2( pTree2, bCurrent );  
-        if ( bNext == NULL )
-        {
-            if ( !pPars->fSilent )
-                printf( "BDDs blew up during image computation.  " );
-            if ( pPars->fPartition )
-                Bbr_bddImageTreeDelete( pTree );
-            else
-                Bbr_bddImageTreeDelete2( pTree2 );
-            Vec_PtrFree( vOnionRings );
-            pPars->iFrame = nIters - 1;
-            return -1;
-        }
-        Cudd_Ref( bNext );
-        Cudd_RecursiveDeref( dd, bCurrent );
-
-        // remap these states into the current state vars
-        bNext = Cudd_bddVarMap( dd, bTemp = bNext );                    Cudd_Ref( bNext );
-        Cudd_RecursiveDeref( dd, bTemp );
-        // check if there are any new states
-        if ( Cudd_bddLeq( dd, bNext, bReached ) ) {
-            fixedPoint = 1;
-            break;
-        }
-        // check the BDD size
-        nBddSize = Cudd_DagSize(bNext);
-        if ( nBddSize > pPars->nBddMax )
-            break;
-        // check the result
-        for ( i = 0; i < Saig_ManPoNum(p); i++ )
-        {
-            if ( fCheckOutputs && !Cudd_bddLeq( dd, bNext, Cudd_Not(pbOutputs[i]) ) )
-            {
-                DdNode * bIntersect;
-                bIntersect = Cudd_bddIntersect( dd, bNext, pbOutputs[i] );  Cudd_Ref( bIntersect );
-                assert( p->pSeqModel == NULL );
-                p->pSeqModel = Aig_ManVerifyUsingBddsCountExample( p, dd, pbParts, 
-                    vOnionRings, bIntersect, i, pPars->fVerbose, pPars->fSilent ); 
-                Cudd_RecursiveDeref( dd, bIntersect );
-                if ( !pPars->fSilent )
-                    Abc_Print( 1, "Output %d of miter \"%s\" was asserted in frame %d. ", i, p->pName, Vec_PtrSize(vOnionRings) );
-                Cudd_RecursiveDeref( dd, bReached );
-                bReached = NULL;
-                pPars->iFrame = nIters;
-                break;
-            }
-        }
-        if ( i < Saig_ManPoNum(p) )
-            break;
-        // get the new states
-        bCurrent = Cudd_bddAnd( dd, bNext, Cudd_Not(bReached) );        Cudd_Ref( bCurrent );
-        Vec_PtrPush( vOnionRings, bCurrent );  Cudd_Ref( bCurrent );
-        // minimize the new states with the reached states
-//        bCurrent = Cudd_bddConstrain( dd, bTemp = bCurrent, Cudd_Not(bReached) ); Cudd_Ref( bCurrent );
-//        Cudd_RecursiveDeref( dd, bTemp );
-        // add to the reached states
-        bReached = Cudd_bddOr( dd, bTemp = bReached, bNext );           Cudd_Ref( bReached );
-        Cudd_RecursiveDeref( dd, bTemp );
-        Cudd_RecursiveDeref( dd, bNext );
-        if ( pPars->fVerbose )
-            fprintf( stdout, "Frame = %3d. BDD = %5d. ", nIters, nBddSize );
-        if ( fInternalReorder && pPars->fReorder && nBddSize > nThreshold )
-        {
-            if ( pPars->fVerbose )
-                fprintf( stdout, "Reordering... Before = %5d. ", Cudd_DagSize(bReached) );
-            Cudd_ReduceHeap( dd, CUDD_REORDER_SYMM_SIFT, 100 );
-            Cudd_AutodynDisable( dd );
-            if ( pPars->fVerbose )
-                fprintf( stdout, "After = %5d.\r", Cudd_DagSize(bReached) );
-            nThreshold *= 2;
-        }
-        if ( pPars->fVerbose )
-//            fprintf( stdout, "\r" );
-            fprintf( stdout, "\n" );
-
-        if ( pPars->fVerbose )
-        {
-            double nMints = Cudd_CountMinterm(dd, bReached, Saig_ManRegNum(p) );
-//            Extra_bddPrint( dd, bReached );printf( "\n" );
-            fprintf( stdout, "Reachable states = %.0f. (Ratio = %.4f %%)\n", nMints, 100.0*nMints/pow(2.0, Saig_ManRegNum(p)) );
-            fflush( stdout ); 
-        }
-
-    }
-    Cudd_RecursiveDeref( dd, bNext );
-    // free the onion rings
-    Vec_PtrForEachEntry( DdNode *, vOnionRings, bTemp, i )
-        Cudd_RecursiveDeref( dd, bTemp );
-    Vec_PtrFree( vOnionRings );
-    // undo the image tree
-    if ( pPars->fPartition )
-        Bbr_bddImageTreeDelete( pTree );
-    else
-        Bbr_bddImageTreeDelete2( pTree2 );
-    if ( bReached == NULL )
-        return 0; // proved reachable
-    // report the stats
-    if ( pPars->fVerbose )
-    {
-        double nMints = Cudd_CountMinterm(dd, bReached, Saig_ManRegNum(p) );
-        if ( nIters > pPars->nIterMax || nBddSize > pPars->nBddMax )
-            fprintf( stdout, "Reachability analysis is stopped after %d frames.\n", nIters );
-        else
-            fprintf( stdout, "Reachability analysis completed after %d frames.\n", nIters );
-        fprintf( stdout, "Reachable states = %.0f. (Ratio = %.4f %%)\n", nMints, 100.0*nMints/pow(2.0, Saig_ManRegNum(p)) );
-        fflush( stdout );
-    }
-//ABC_PRB( dd, bReached );
-    Cudd_RecursiveDeref( dd, bReached );
-    // SPG
-    //
-    if ( fixedPoint ) {
-      if ( !pPars->fSilent ) {
-        printf( "The miter is proved unreachable after %d iterations.  ", nIters );
-      }
-      pPars->iFrame = nIters - 1;
-      return 1;
-    }
-    assert(nIters >= pPars->nIterMax || nBddSize >= pPars->nBddMax);
-    if ( !pPars->fSilent )
-      printf( "Verified only for states reachable in %d frames.  ", nIters );
-    pPars->iFrame = nIters - 1;
-    return -1; // undecided
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Performs reachability to see if any PO can be asserted.]
-
-  Description []
-               
-  SideEffects []
- 
-  SeeAlso     []
-
-***********************************************************************/
-int Aig_ManVerifyUsingBdds_int( Aig_Man_t * p, Saig_ParBbr_t * pPars )
-{
-    int fCheckOutputs = !pPars->fSkipOutCheck;
-    DdManager * dd;
-    DdNode ** pbParts, ** pbOutputs;
-    DdNode * bInitial, * bTemp;
-    int RetValue, i;
-    abctime clk = Abc_Clock();
-    Vec_Ptr_t * vOnionRings;
-
-    assert( Saig_ManRegNum(p) > 0 );
-
-    // compute the global BDDs of the latches
-    dd = Aig_ManComputeGlobalBdds( p, pPars->nBddMax, 1, pPars->fReorder, pPars->fVerbose );    
-    if ( dd == NULL )
-    {
-        if ( !pPars->fSilent )
-            printf( "The number of intermediate BDD nodes exceeded the limit (%d).\n", pPars->nBddMax );
-        return -1;
-    }
-    if ( pPars->fVerbose )
-        printf( "Shared BDD size is %6d nodes.\n", Cudd_ReadKeys(dd) - Cudd_ReadDead(dd) );
-
-    // check the runtime limit
-    if ( pPars->TimeLimit && pPars->TimeLimit <= (Abc_Clock()-clk)/CLOCKS_PER_SEC )
-    {
-        printf( "Reached timeout after constructing global BDDs (%d seconds).\n",  pPars->TimeLimit );
-        Cudd_Quit( dd );
-        return -1;
-    }
-
-    // start the onion rings
-    vOnionRings = Vec_PtrAlloc( 1000 );
-
-    // save outputs
-    pbOutputs = Aig_ManCreateOutputs( dd, p );
-
-    // create partitions
-    pbParts = Aig_ManCreatePartitions( dd, p, pPars->fReorder, pPars->fVerbose );
-
-    // create the initial state and the variable map
-    bInitial  = Aig_ManInitStateVarMap( dd, p, pPars->fVerbose );  Cudd_Ref( bInitial );
-
-    // set reordering
-    if ( pPars->fReorderImage )
-        Cudd_AutodynEnable( dd, CUDD_REORDER_SYMM_SIFT );
-
-    // check the result
-    RetValue = -1;
-    for ( i = 0; i < Saig_ManPoNum(p); i++ )
-    {
-        if ( fCheckOutputs && !Cudd_bddLeq( dd, bInitial, Cudd_Not(pbOutputs[i]) ) )
-        {
-            DdNode * bIntersect;
-            bIntersect = Cudd_bddIntersect( dd, bInitial, pbOutputs[i] );  Cudd_Ref( bIntersect );
-            assert( p->pSeqModel == NULL );
-            p->pSeqModel = Aig_ManVerifyUsingBddsCountExample( p, dd, pbParts, 
-                vOnionRings, bIntersect, i, pPars->fVerbose, pPars->fSilent ); 
-            Cudd_RecursiveDeref( dd, bIntersect );
-            if ( !pPars->fSilent )
-                Abc_Print( 1, "Output %d of miter \"%s\" was asserted in frame %d. ", i, p->pName, -1 );
-            RetValue = 0;
-            break;
-        }
-    }
-    // free the onion rings
-    Vec_PtrForEachEntry( DdNode *, vOnionRings, bTemp, i )
-        Cudd_RecursiveDeref( dd, bTemp );
-    Vec_PtrFree( vOnionRings );
-    // explore reachable states
-    if ( RetValue == -1 )
-        RetValue = Aig_ManComputeReachable( dd, p, pbParts, bInitial, pbOutputs, pPars, fCheckOutputs ); 
-
-    // cleanup
-    Cudd_RecursiveDeref( dd, bInitial );
-    for ( i = 0; i < Saig_ManRegNum(p); i++ )
-        Cudd_RecursiveDeref( dd, pbParts[i] );
-    ABC_FREE( pbParts );
-    for ( i = 0; i < Saig_ManPoNum(p); i++ )
-        Cudd_RecursiveDeref( dd, pbOutputs[i] );
-    ABC_FREE( pbOutputs );
-//    if ( RetValue == -1 )
-        Cudd_Quit( dd );
-//    else
-//        Bbr_StopManager( dd );
-
-    // report the runtime
-    if ( !pPars->fSilent )
-    {
-    ABC_PRT( "Time", Abc_Clock() - clk );
-    fflush( stdout );
-    }
-    return RetValue;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Performs reachability to see if any PO can be asserted.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Aig_ManVerifyUsingBdds( Aig_Man_t * pInit, Saig_ParBbr_t * pPars )
-{
-    Abc_Cex_t * pCexOld, * pCexNew;
-    Aig_Man_t * p;
-    Aig_Obj_t * pObj;
-    Vec_Int_t * vInputMap;
-    int i, k, Entry, iBitOld, iBitNew, RetValue;
-//    pPars->fVerbose = 1;
-    // check if there are PIs without fanout
-    Saig_ManForEachPi( pInit, pObj, i )
-        if ( Aig_ObjRefs(pObj) == 0 )
-            break;
-    if ( i == Saig_ManPiNum(pInit) )
-        return Aig_ManVerifyUsingBdds_int( pInit, pPars );
-    // create new AIG
-    p = Aig_ManDupTrim( pInit );
-    assert( Aig_ManCiNum(p) < Aig_ManCiNum(pInit) );
-    assert( Aig_ManRegNum(p) == Aig_ManRegNum(pInit) );
-    RetValue = Aig_ManVerifyUsingBdds_int( p, pPars );
-    if ( RetValue != 0 )
-    {
-        Aig_ManStop( p );
-        return RetValue;
-    }
-    // the problem is satisfiable - remap the pattern
-    pCexOld = p->pSeqModel;
-    assert( pCexOld != NULL );
-    // create input map
-    vInputMap = Vec_IntAlloc( Saig_ManPiNum(pInit) );
-    Saig_ManForEachPi( pInit, pObj, i )
-        if ( pObj->pData != NULL )
-            Vec_IntPush( vInputMap, Aig_ObjCioId((Aig_Obj_t *)pObj->pData) );
-        else
-            Vec_IntPush( vInputMap, -1 );
-    // create new pattern
-    pCexNew = Abc_CexAlloc( Saig_ManRegNum(pInit), Saig_ManPiNum(pInit), pCexOld->iFrame+1 );
-    pCexNew->iFrame = pCexOld->iFrame;
-    pCexNew->iPo    = pCexOld->iPo;
-    // copy the bit-data
-    for ( iBitOld = 0; iBitOld < pCexOld->nRegs; iBitOld++ )
-        if ( Abc_InfoHasBit( pCexOld->pData, iBitOld ) )
-            Abc_InfoSetBit( pCexNew->pData, iBitOld );
-    // copy the primary input data
-    iBitNew = iBitOld;
-    for ( i = 0; i <= pCexNew->iFrame; i++ )
-    {
-        Vec_IntForEachEntry( vInputMap, Entry, k )
-        {
-            if ( Entry == -1 )
-                continue;
-            if ( Abc_InfoHasBit( pCexOld->pData, iBitOld + Entry ) )
-                Abc_InfoSetBit( pCexNew->pData, iBitNew + k );
-        }
-        iBitOld += Saig_ManPiNum(p);
-        iBitNew += Saig_ManPiNum(pInit);
-    }
-    assert( iBitOld < iBitNew );
-    assert( iBitOld == pCexOld->nBits );
-    assert( iBitNew == pCexNew->nBits );
-    Vec_IntFree( vInputMap );
-    pInit->pSeqModel = pCexNew;
-    Aig_ManStop( p );
-    return 0;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/bbr/bbr_.c b/src/proof/bbr/bbr_.c
deleted file mode 100644
index df934f7d..00000000
--- a/src/proof/bbr/bbr_.c
+++ /dev/null
@@ -1,52 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName []
-
-  Synopsis    []
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: .c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "__Int.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/bbr/module.make b/src/proof/bbr/module.make
deleted file mode 100644
index 11ba768e..00000000
--- a/src/proof/bbr/module.make
+++ /dev/null
@@ -1,4 +0,0 @@
-SRC +=    src/proof/bbr/bbrCex.c \
-    src/proof/bbr/bbrImage.c \
-    src/proof/bbr/bbrNtbdd.c \
-    src/proof/bbr/bbrReach.c
diff --git a/src/proof/llb/llb.c b/src/proof/llb/llb.c
deleted file mode 100644
index 348c0622..00000000
--- a/src/proof/llb/llb.c
+++ /dev/null
@@ -1,52 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [llb.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD based reachability.]
-
-  Synopsis    []
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: llb.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "llbInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/llb/llb.h b/src/proof/llb/llb.h
deleted file mode 100644
index f465359d..00000000
--- a/src/proof/llb/llb.h
+++ /dev/null
@@ -1,96 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [llb.h]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD-based reachability.]
-
-  Synopsis    [External declarations.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - May 8, 2010.]
-
-  Revision    [$Id: llb.h,v 1.00 2010/05/08 00:00:00 alanmi Exp $]
-
-***********************************************************************/
- 
-#ifndef ABC__aig__llb__llb_h
-#define ABC__aig__llb__llb_h
-
- 
-////////////////////////////////////////////////////////////////////////
-///                          INCLUDES                                ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                         PARAMETERS                               ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_HEADER_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                         BASIC TYPES                              ///
-////////////////////////////////////////////////////////////////////////
-  
-typedef struct Gia_ParLlb_t_ Gia_ParLlb_t;
-struct Gia_ParLlb_t_
-{
-    int         nBddMax;       // maximum BDD size
-    int         nIterMax;      // maximum iteration count
-    int         nClusterMax;   // maximum cluster size
-    int         nHintDepth;    // the number of times to cofactor
-    int         HintFirst;     // the number of first hint to use
-    int         fUseFlow;      // use flow computation
-    int         nVolumeMax;    // the largest volume
-    int         nVolumeMin;    // the smallest volume
-    int         nPartValue;    // partitioning value
-    int         fBackward;     // enable backward reachability
-    int         fReorder;      // enable dynamic variable reordering
-    int         fIndConstr;    // extract inductive constraints
-    int         fUsePivots;    // use internal pivot variables
-    int         fCluster;      // use partition clustering
-    int         fSchedule;     // use cluster scheduling
-    int         fDumpReached;  // dump reached states into a file
-    int         fVerbose;      // print verbose information
-    int         fVeryVerbose;  // print dependency matrices
-    int         fSilent;       // do not print any infomation
-    int         fSkipReach;    // skip reachability (preparation phase only)
-    int         fSkipOutCheck; // does not check the property output
-    int         TimeLimit;     // time limit for one reachability run
-    int         TimeLimitGlo;  // time limit for all reachability runs
-    // internal parameters
-    abctime     TimeTarget;    // the time to stop
-    int         iFrame;        // explored up to this frame
-};
-
-////////////////////////////////////////////////////////////////////////
-///                      MACRO DEFINITIONS                           ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                    FUNCTION DECLARATIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/*=== llbCore.c ==========================================================*/
-extern void     Llb_ManSetDefaultParams( Gia_ParLlb_t * pPars );
-/*=== llb4Nonlin.c ==========================================================*/
-extern int      Llb_Nonlin4CoreReach( Aig_Man_t * pAig, Gia_ParLlb_t * pPars );
-
-
-
-ABC_NAMESPACE_HEADER_END
-
-
-
-#endif
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
diff --git a/src/proof/llb/llb1Cluster.c b/src/proof/llb/llb1Cluster.c
deleted file mode 100644
index 1356e484..00000000
--- a/src/proof/llb/llb1Cluster.c
+++ /dev/null
@@ -1,356 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [llb1Cluster.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD based reachability.]
-
-  Synopsis    [Clustering algorithm.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
- 
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: llb1Cluster.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "llbInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_ManComputeCommonQuant( Llb_Mtr_t * p, int iCol1, int iCol2 )
-{
-    int iVar, Weight = 0;
-    for ( iVar = 0; iVar < p->nRows - p->nFfs; iVar++ )
-    {
-        // count each removed variable as 2
-        if ( p->pMatrix[iCol1][iVar] == 1 && p->pMatrix[iCol2][iVar] == 1 && p->pRowSums[iVar] == 2 )
-            Weight += 2;
-        // count each added variale as -1
-        else if ( (p->pMatrix[iCol1][iVar] == 1 && p->pMatrix[iCol2][iVar] == 0) || 
-                  (p->pMatrix[iCol1][iVar] == 0 && p->pMatrix[iCol2][iVar] == 1) )
-            Weight--;
-    }
-    return Weight;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_ManComputeBestQuant( Llb_Mtr_t * p )
-{
-    int i, k, WeightBest = -100000, WeightCur, RetValue = -1;
-    for ( i = 1; i < p->nCols-1; i++ )
-    for ( k = i+1; k < p->nCols-1; k++ )
-    {
-        if ( p->pColSums[i] == 0 || p->pColSums[i] > p->pMan->pPars->nClusterMax )
-            continue;
-        if ( p->pColSums[k] == 0 || p->pColSums[k] > p->pMan->pPars->nClusterMax )
-            continue;
-
-        WeightCur = Llb_ManComputeCommonQuant( p, i, k );
-        if ( WeightCur <= 0 )
-            continue;
-        if ( WeightBest < WeightCur )
-        {
-            WeightBest = WeightCur;
-            RetValue   = (i << 16) | k;
-        }
-    }
-//    printf( "Choosing best quant Weight %4d\n", WeightCur );
-    return RetValue;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-float ** Llb_ManComputeQuant( Llb_Mtr_t * p )
-{
-    float ** pCosts;
-    int i, k;
-    // alloc and clean
-    pCosts = (float **)Extra_ArrayAlloc( p->nCols, p->nCols, sizeof(float) );
-    for ( i = 0; i < p->nCols; i++ )
-    for ( k = 0; k < p->nCols; k++ )
-        pCosts[i][i] = 0.0;
-    // fill up
-    for ( i = 1; i < p->nCols-1; i++ )
-    for ( k = i+1; k < p->nCols-1; k++ )
-        pCosts[i][k] = pCosts[k][i] = Llb_ManComputeCommonQuant( p, i, k );
-    return pCosts;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-float Llb_ManComputeCommonAttr( Llb_Mtr_t * p, int iCol1, int iCol2 )
-{
-    int iVar, CountComm = 0, CountDiff = 0;
-    for ( iVar = 0; iVar < p->nRows - p->nFfs; iVar++ )
-    {
-        if ( p->pMatrix[iCol1][iVar] == 1 && p->pMatrix[iCol2][iVar] == 1 )
-            CountComm++;
-        else if ( p->pMatrix[iCol1][iVar] == 1 || p->pMatrix[iCol2][iVar] == 1 )
-            CountDiff++;
-    }
-/*
-    printf( "Attr cost for %4d and %4d:  %4d %4d (%5.2f)\n", 
-        iCol1, iCol2, 
-        CountDiff, CountComm, 
-        -1.0 * CountDiff / ( CountComm + CountDiff ) );
-*/
-    return -1.0 * CountDiff / ( CountComm + CountDiff );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_ManComputeBestAttr( Llb_Mtr_t * p )
-{
-    float WeightBest = -100000, WeightCur;
-    int i, k, RetValue = -1;
-    for ( i = 1; i < p->nCols-1; i++ )
-    for ( k = i+1; k < p->nCols-1; k++ )
-    {
-        if ( p->pColSums[i] == 0 || p->pColSums[i] > p->pMan->pPars->nClusterMax )
-            continue;
-        if ( p->pColSums[k] == 0 || p->pColSums[k] > p->pMan->pPars->nClusterMax )
-            continue;
-        WeightCur = Llb_ManComputeCommonAttr( p, i, k );
-        if ( WeightBest < WeightCur )
-        {
-            WeightBest = WeightCur;
-            RetValue   = (i << 16) | k;
-        }
-    }
-    return RetValue;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-float ** Llb_ManComputeAttr( Llb_Mtr_t * p )
-{
-    float ** pCosts;
-    int i, k;
-    // alloc and clean
-    pCosts = (float **)Extra_ArrayAlloc( p->nCols, p->nCols, sizeof(float) );
-    for ( i = 0; i < p->nCols; i++ )
-    for ( k = 0; k < p->nCols; k++ )
-        pCosts[i][i] = 0.0;
-    // fill up
-    for ( i = 1; i < p->nCols-1; i++ )
-    for ( k = i+1; k < p->nCols-1; k++ )
-        pCosts[i][k] = pCosts[k][i] = Llb_ManComputeCommonAttr( p, i, k );
-    return pCosts;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Returns the number of variables that will be saved.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_MtrCombineSelectedColumns( Llb_Mtr_t * p, int iGrp1, int iGrp2 )
-{
-    int iVar;
-    assert( iGrp1 >= 1 && iGrp1 < p->nCols - 1 );
-    assert( iGrp2 >= 1 && iGrp2 < p->nCols - 1 );
-    assert( p->pColGrps[iGrp1] != NULL );
-    assert( p->pColGrps[iGrp2] != NULL );
-    for ( iVar = 0; iVar < p->nRows; iVar++ )
-    {
-        if ( p->pMatrix[iGrp1][iVar] == 1 && p->pMatrix[iGrp2][iVar] == 1 )
-            p->pRowSums[iVar]--;
-        if ( p->pMatrix[iGrp1][iVar] == 0 && p->pMatrix[iGrp2][iVar] == 1 )
-        {
-            p->pMatrix[iGrp1][iVar] = 1;
-            p->pColSums[iGrp1]++;
-        }
-        if ( p->pMatrix[iGrp2][iVar] == 1 )
-            p->pMatrix[iGrp2][iVar] = 0;
-    }
-    p->pColSums[iGrp2] = 0;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Combines one pair of columns.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManClusterOne( Llb_Mtr_t * p, int iCol1, int iCol2 )
-{
-    int fVerbose = 0;
-    Llb_Grp_t * pGrp;
-    int iVar;
-
-    if ( fVerbose )
-    {
-        printf( "Combining %d and %d\n", iCol1, iCol2 );
-        for ( iVar = 0; iVar < p->nRows; iVar++ )
-        {
-            if ( p->pMatrix[iCol1][iVar] == 0 && p->pMatrix[iCol2][iVar] == 0 )
-                continue;
-            printf( "%3d : %c%c\n", iVar, 
-                p->pMatrix[iCol1][iVar]? '*':' ', 
-                p->pMatrix[iCol2][iVar]? '*':' ' );
-        }
-    }
-    pGrp = Llb_ManGroupsCombine( p->pColGrps[iCol1], p->pColGrps[iCol2] );
-    Llb_MtrCombineSelectedColumns( p, iCol1, iCol2 );
-    p->pColGrps[iCol1] = pGrp;
-    p->pColGrps[iCol2] = NULL;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Removes empty columns.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManClusterCompress( Llb_Mtr_t * p )
-{
-    int i, k = 0;
-    for ( i = 0; i < p->nCols; i++ )
-    {
-        if ( p->pColGrps[i] == NULL )
-        {
-            assert( p->pColSums[i] == 0 );
-            assert( p->pMatrix[i] != NULL );
-            ABC_FREE( p->pMatrix[i] );
-            continue;
-        }
-        p->pMatrix[k]  = p->pMatrix[i];
-        p->pColGrps[k] = p->pColGrps[i];
-        p->pColSums[k] = p->pColSums[i];
-        k++;
-    }
-    p->nCols = k;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Combines one pair of columns.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManCluster( Llb_Mtr_t * p )
-{
-    int RetValue;
-    do
-    {
-        do {
-            RetValue = Llb_ManComputeBestQuant( p );
-            if ( RetValue > 0 )
-                Llb_ManClusterOne( p, RetValue >> 16, RetValue & 0xffff );
-        }
-        while ( RetValue > 0 );
-
-        RetValue = Llb_ManComputeBestAttr( p );
-        if ( RetValue > 0 )
-            Llb_ManClusterOne( p, RetValue >> 16, RetValue & 0xffff );
-
-        Llb_MtrVerifyMatrix( p );
-    }
-    while ( RetValue > 0 );
-
-    Llb_ManClusterCompress( p );
-
-    Llb_MtrVerifyMatrix( p );
-}
-
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/llb/llb1Constr.c b/src/proof/llb/llb1Constr.c
deleted file mode 100644
index 1ef4ce14..00000000
--- a/src/proof/llb/llb1Constr.c
+++ /dev/null
@@ -1,313 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [llb1Constr.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD based reachability.]
-
-  Synopsis    [Computing inductive constraints.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: llb1Constr.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "llbInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Returns the array of constraint candidates.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_ManCountEntries( Vec_Int_t * vCands )
-{
-    int i, Entry, Counter = 0;
-    Vec_IntForEachEntry( vCands, Entry, i )
-        Counter += ((Entry == 0) || (Entry == 1));
-    return Counter;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns the array of constraint candidates.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManPrintEntries( Aig_Man_t * p, Vec_Int_t * vCands )
-{
-    int i, Entry;
-    if ( vCands == NULL )
-    {
-        printf( "There is no hints.\n" );
-        return;
-    }
-    Entry = Llb_ManCountEntries(vCands);
-    printf( "\n*** Using %d hint%s:\n", Entry, (Entry != 1 ? "s":"") );
-    Vec_IntForEachEntry( vCands, Entry, i )
-    {
-        if ( Entry != 0 && Entry != 1 )
-            continue;
-        printf( "%c", Entry ? '+' : '-' );
-        printf( "%-6d : ", i );
-        Aig_ObjPrint( p, Aig_ManObj(p, i) );
-        printf( "\n" );
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Dereference BDD nodes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManDerefenceBdds( Aig_Man_t * p, DdManager * dd )
-{
-    Aig_Obj_t * pObj;
-    int i;
-    Aig_ManForEachObj( p, pObj, i )
-        Cudd_RecursiveDeref( dd, (DdNode *)pObj->pData );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns the array of constraint candidates.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb_ManComputeIndCase_rec( Aig_Man_t * p, Aig_Obj_t * pObj, DdManager * dd, Vec_Ptr_t * vBdds )
-{
-    DdNode * bBdd0, * bBdd1;
-    DdNode * bFunc = (DdNode *)Vec_PtrEntry( vBdds, Aig_ObjId(pObj) );
-    if ( bFunc != NULL )
-        return bFunc;
-    assert( Aig_ObjIsNode(pObj) );
-    bBdd0 = Llb_ManComputeIndCase_rec( p, Aig_ObjFanin0(pObj), dd, vBdds ); 
-    bBdd1 = Llb_ManComputeIndCase_rec( p, Aig_ObjFanin1(pObj), dd, vBdds ); 
-    bBdd0 = Cudd_NotCond( bBdd0, Aig_ObjFaninC0(pObj) );
-    bBdd1 = Cudd_NotCond( bBdd1, Aig_ObjFaninC1(pObj) );
-    bFunc = Cudd_bddAnd( dd, bBdd0, bBdd1 );  Cudd_Ref( bFunc );
-    Vec_PtrWriteEntry( vBdds, Aig_ObjId(pObj), bFunc );
-    return bFunc;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns the array of constraint candidates.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManComputeIndCase( Aig_Man_t * p, DdManager * dd, Vec_Int_t * vNodes )
-{
-    Vec_Ptr_t * vBdds;
-    Aig_Obj_t * pObj;
-    DdNode * bFunc;
-    int i, Entry;
-    vBdds = Vec_PtrStart( Aig_ManObjNumMax(p) );
-    bFunc = Cudd_ReadOne(dd); Cudd_Ref( bFunc );
-    Vec_PtrWriteEntry( vBdds, Aig_ObjId(Aig_ManConst1(p)), bFunc );
-    Saig_ManForEachPi( p, pObj, i )
-    {
-        bFunc = Cudd_bddIthVar( dd, Aig_ManCiNum(p) + i );  Cudd_Ref( bFunc );
-        Vec_PtrWriteEntry( vBdds, Aig_ObjId(pObj), bFunc );
-    }
-    Saig_ManForEachLi( p, pObj, i )
-    {
-        bFunc = (DdNode *)pObj->pData;  Cudd_Ref( bFunc );
-        Vec_PtrWriteEntry( vBdds, Aig_ObjId(Saig_ObjLiToLo(p, pObj)), bFunc );
-    }
-    Vec_IntForEachEntry( vNodes, Entry, i )
-    { 
-        if ( Entry != 0 && Entry != 1 )
-            continue;
-        pObj = Aig_ManObj( p, i );
-        bFunc = Llb_ManComputeIndCase_rec( p, pObj, dd, vBdds );
-        if ( Entry == 0 )
-        {
-//            Extra_bddPrint( dd, Cudd_Not(pObj->pData) );  printf( "\n" );
-//            Extra_bddPrint( dd, Cudd_Not(bFunc) );        printf( "\n" );
-            if ( !Cudd_bddLeq( dd, Cudd_Not(pObj->pData), Cudd_Not(bFunc) ) )
-                Vec_IntWriteEntry( vNodes, i, -1 );
-        }
-        else if ( Entry == 1 )
-        {
-//            Extra_bddPrint( dd, pObj->pData );  printf( "\n" );
-//            Extra_bddPrint( dd, bFunc );        printf( "\n" );
-            if ( !Cudd_bddLeq( dd, (DdNode *)pObj->pData, bFunc ) )
-                Vec_IntWriteEntry( vNodes, i, -1 );
-        }
-    }
-    Vec_PtrForEachEntry( DdNode *, vBdds, bFunc, i )
-        if ( bFunc )
-            Cudd_RecursiveDeref( dd, bFunc );
-    Vec_PtrFree( vBdds );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns the array of constraint candidates.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Int_t * Llb_ManComputeBaseCase( Aig_Man_t * p, DdManager * dd )
-{
-    Vec_Int_t * vNodes;
-    Aig_Obj_t * pObj, * pRoot;
-    int i;
-    pRoot = Aig_ManCo( p, 0 );
-    vNodes = Vec_IntStartFull( Aig_ManObjNumMax(p) );
-    Aig_ManForEachObj( p, pObj, i )
-    {
-        if ( !Aig_ObjIsNode(pObj) && !Aig_ObjIsCi(pObj) )
-            continue;
-        if ( Cudd_bddLeq( dd, (DdNode *)pObj->pData, Cudd_Not(pRoot->pData) ) )
-            Vec_IntWriteEntry( vNodes, i, 1 );
-        else if ( Cudd_bddLeq( dd, Cudd_Not((DdNode *)pObj->pData), Cudd_Not(pRoot->pData) ) )
-            Vec_IntWriteEntry( vNodes, i, 0 );
-    }
-    return vNodes;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Constructs global BDDs for each object in the AIG manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdManager * Llb_ManConstructGlobalBdds( Aig_Man_t * p )
-{
-    DdManager * dd;
-    DdNode * bBdd0, * bBdd1;
-    Aig_Obj_t * pObj;
-    int i;
-    dd = Cudd_Init( Aig_ManCiNum(p), 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
-    Cudd_AutodynEnable( dd,  CUDD_REORDER_SYMM_SIFT );
-    pObj = Aig_ManConst1(p);
-    pObj->pData = Cudd_ReadOne(dd);  Cudd_Ref( (DdNode *)pObj->pData );
-    Aig_ManForEachCi( p, pObj, i )
-    {
-        pObj->pData = Cudd_bddIthVar(dd, i);  Cudd_Ref( (DdNode *)pObj->pData );
-    }
-    Aig_ManForEachNode( p, pObj, i )
-    {
-        bBdd0 = Cudd_NotCond( (DdNode *)Aig_ObjFanin0(pObj)->pData, Aig_ObjFaninC0(pObj) );
-        bBdd1 = Cudd_NotCond( (DdNode *)Aig_ObjFanin1(pObj)->pData, Aig_ObjFaninC1(pObj) );
-        pObj->pData = Cudd_bddAnd( dd, bBdd0, bBdd1 );   Cudd_Ref( (DdNode *)pObj->pData );
-    }
-    Aig_ManForEachCo( p, pObj, i )
-    {
-        pObj->pData = Cudd_NotCond( (DdNode *)Aig_ObjFanin0(pObj)->pData, Aig_ObjFaninC0(pObj) );  Cudd_Ref( (DdNode *)pObj->pData );
-    }
-    return dd;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Derives inductive constraints.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Int_t * Llb_ManDeriveConstraints( Aig_Man_t * p )
-{
-    DdManager * dd;
-    Vec_Int_t * vNodes;
-    if ( Saig_ManPoNum(p) != 1 )
-    {
-        printf( "The AIG has %d property outputs.\n", Saig_ManPoNum(p) );
-        return NULL;
-    }
-    assert( Saig_ManPoNum(p) == 1 );
-    dd = Llb_ManConstructGlobalBdds( p );
-    vNodes = Llb_ManComputeBaseCase( p, dd );
-    if ( Llb_ManCountEntries(vNodes) > 0 )
-        Llb_ManComputeIndCase( p, dd, vNodes );
-    if ( Llb_ManCountEntries(vNodes) == 0 )
-        Vec_IntFreeP( &vNodes );
-    Llb_ManDerefenceBdds( p, dd );
-    Extra_StopManager( dd );
-    return vNodes;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Tests derived constraints.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManConstrTest( Aig_Man_t * p )
-{
-    Vec_Int_t * vNodes;
-    vNodes = Llb_ManDeriveConstraints( p );
-    Llb_ManPrintEntries( p, vNodes );
-    Vec_IntFreeP( &vNodes );
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/llb/llb1Core.c b/src/proof/llb/llb1Core.c
deleted file mode 100644
index 213f2cd9..00000000
--- a/src/proof/llb/llb1Core.c
+++ /dev/null
@@ -1,222 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [llb1Core.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD based reachability.]
-
-  Synopsis    [Top-level procedure.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: llb1Core.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "llbInt.h"
-#include "aig/gia/gia.h"
-#include "aig/gia/giaAig.h"
-
-ABC_NAMESPACE_IMPL_START
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
- 
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
- 
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManSetDefaultParams( Gia_ParLlb_t * p )
-{
-    memset( p, 0, sizeof(Gia_ParLlb_t) );
-    p->nBddMax       = 10000000;
-    p->nIterMax      = 10000000;
-    p->nClusterMax   =       20;
-    p->nHintDepth    =        0;
-    p->HintFirst     =        0;
-    p->fUseFlow      =        0;  // use flow 
-    p->nVolumeMax    =      100;  // max volume
-    p->nVolumeMin    =       30;  // min volume
-    p->nPartValue    =        5;  // partitioning value
-    p->fBackward     =        0;  // forward by default
-    p->fReorder      =        1;
-    p->fIndConstr    =        0;
-    p->fUsePivots    =        0;
-    p->fCluster      =        0;
-    p->fSchedule     =        0;
-    p->fDumpReached  =        0;
-    p->fVerbose      =        0;
-    p->fVeryVerbose  =        0;
-    p->fSilent       =        0;
-    p->TimeLimit     =        0;
-//    p->TimeLimit     =        0;
-    p->TimeLimitGlo  =        0;
-    p->TimeTarget    =        0;
-    p->iFrame        =       -1;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Prints statistics about MFFCs.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManPrintAig( Llb_Man_t * p )
-{
-    Abc_Print( 1, "pi =%3d  ",    Saig_ManPiNum(p->pAig) );
-    Abc_Print( 1, "po =%3d  ",    Saig_ManPoNum(p->pAig) );
-    Abc_Print( 1, "ff =%3d  ",    Saig_ManRegNum(p->pAig) );
-    Abc_Print( 1, "int =%5d  ",   Vec_IntSize(p->vVar2Obj)-Aig_ManCiNum(p->pAig)-Saig_ManRegNum(p->pAig) );
-    Abc_Print( 1, "var =%5d  ",   Vec_IntSize(p->vVar2Obj) );
-    Abc_Print( 1, "part =%5d  ",  Vec_PtrSize(p->vGroups)-2 );
-    Abc_Print( 1, "and =%5d  ",   Aig_ManNodeNum(p->pAig) );
-    Abc_Print( 1, "lev =%4d  ",   Aig_ManLevelNum(p->pAig) );
-//    Abc_Print( 1, "cut =%4d  ",   Llb_ManCrossCut(p->pAig) );
-    Abc_Print( 1, "\n" );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_ManModelCheckAig( Aig_Man_t * pAigGlo, Gia_ParLlb_t * pPars, Vec_Int_t * vHints, DdManager ** pddGlo )
-{
-    Llb_Man_t * p = NULL; 
-    Aig_Man_t * pAig;
-    int RetValue = -1;
-    abctime clk = Abc_Clock();
-
-    if ( pPars->fIndConstr )
-    {
-        assert( vHints == NULL );
-        vHints = Llb_ManDeriveConstraints( pAigGlo );
-    }
-
-    // derive AIG for hints
-    if ( vHints == NULL )
-        pAig = Aig_ManDupSimple( pAigGlo );
-    else
-    {
-        if ( pPars->fVerbose )
-            Llb_ManPrintEntries( pAigGlo, vHints );
-        pAig = Aig_ManDupSimpleWithHints( pAigGlo, vHints );
-    }
-
-
-    if ( pPars->fUseFlow )
-    {
-//        p = Llb_ManStartFlow( pAigGlo, pAig, pPars );
-    }
-    else
-    {
-        p = Llb_ManStart( pAigGlo, pAig, pPars );
-        if ( pPars->fVerbose )
-        {
-            Llb_ManPrintAig( p );
-            printf( "Original matrix:          " );
-            Llb_MtrPrintMatrixStats( p->pMatrix );
-            if ( pPars->fVeryVerbose )
-                Llb_MtrPrint( p->pMatrix, 1 );
-        }
-        if ( pPars->fCluster )
-        {
-            Llb_ManCluster( p->pMatrix );
-            if ( pPars->fVerbose )
-            {
-                printf( "Matrix after clustering:  " );
-                Llb_MtrPrintMatrixStats( p->pMatrix );
-                if ( pPars->fVeryVerbose )
-                    Llb_MtrPrint( p->pMatrix, 1 );
-            }
-        }
-        if ( pPars->fSchedule )
-        {
-            Llb_MtrSchedule( p->pMatrix );
-            if ( pPars->fVerbose )
-            {
-                printf( "Matrix after scheduling:  " );
-                Llb_MtrPrintMatrixStats( p->pMatrix );
-                if ( pPars->fVeryVerbose )
-                    Llb_MtrPrint( p->pMatrix, 1 );
-            }
-        }
-    }
-    
-    if ( !p->pPars->fSkipReach ) 
-        RetValue = Llb_ManReachability( p, vHints, pddGlo );
-    Llb_ManStop( p );
-
-    Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
-
-    if ( pPars->fIndConstr )
-        Vec_IntFreeP( &vHints );
-    return RetValue;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_ManModelCheckGia( Gia_Man_t * pGia, Gia_ParLlb_t * pPars )
-{
-    Gia_Man_t * pGia2;
-    Aig_Man_t * pAig;
-    int RetValue = -1;
-    pGia2 = Gia_ManDupDfs( pGia );
-    pAig  = Gia_ManToAigSimple( pGia2 );
-    Gia_ManStop( pGia2 );
-//Aig_ManShow( pAig, 0, NULL ); 
-
-    if ( pPars->nHintDepth == 0 )
-        RetValue = Llb_ManModelCheckAig( pAig, pPars, NULL, NULL );
-    else
-        RetValue = Llb_ManModelCheckAigWithHints( pAig, pPars );
-    pGia->pCexSeq = pAig->pSeqModel; pAig->pSeqModel = NULL;
-    Aig_ManStop( pAig );
-    return RetValue;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/llb/llb1Group.c b/src/proof/llb/llb1Group.c
deleted file mode 100644
index 1099b2cd..00000000
--- a/src/proof/llb/llb1Group.c
+++ /dev/null
@@ -1,474 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [llb1Group.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD based reachability.]
-
-  Synopsis    [Initial partition computation.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: llb1Group.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "llbInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Llb_Grp_t * Llb_ManGroupAlloc( Llb_Man_t * pMan )
-{
-    Llb_Grp_t * p;
-    p = ABC_CALLOC( Llb_Grp_t, 1 );
-    p->pMan   = pMan;
-    p->vIns   = Vec_PtrAlloc( 8 );
-    p->vOuts  = Vec_PtrAlloc( 8 );
-    p->Id     = Vec_PtrSize( pMan->vGroups );
-    Vec_PtrPush( pMan->vGroups, p );
-    return p;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManGroupStop( Llb_Grp_t * p )
-{
-    if ( p == NULL )
-        return;
-    Vec_PtrWriteEntry( p->pMan->vGroups, p->Id, NULL );
-    Vec_PtrFreeP( &p->vIns );
-    Vec_PtrFreeP( &p->vOuts );
-    Vec_PtrFreeP( &p->vNodes );
-    ABC_FREE( p );
-}
-
- 
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManGroupCollect_rec( Aig_Man_t * pAig, Aig_Obj_t * pObj, Vec_Ptr_t * vNodes )
-{
-    if ( Aig_ObjIsTravIdCurrent(pAig, pObj) )
-        return;
-    Aig_ObjSetTravIdCurrent(pAig, pObj);
-    if ( Aig_ObjIsConst1(pObj) )
-        return;
-    if ( Aig_ObjIsCo(pObj) )
-    {
-        Llb_ManGroupCollect_rec( pAig, Aig_ObjFanin0(pObj), vNodes );
-        return;
-    }
-    assert( Aig_ObjIsAnd(pObj) );
-    Llb_ManGroupCollect_rec( pAig, Aig_ObjFanin0(pObj), vNodes );
-    Llb_ManGroupCollect_rec( pAig, Aig_ObjFanin1(pObj), vNodes );
-    Vec_PtrPush( vNodes, pObj );
-}
- 
-/**Function*************************************************************
-
-  Synopsis    [Collects the support of MFFC.]
-
-  Description [Returns the number of internal nodes in the MFFC.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Ptr_t * Llb_ManGroupCollect( Llb_Grp_t * pGroup )
-{
-    Vec_Ptr_t * vNodes;
-    Aig_Obj_t * pObj;
-    int i;
-    vNodes = Vec_PtrAlloc( 100 );
-    Aig_ManIncrementTravId( pGroup->pMan->pAig );
-    Vec_PtrForEachEntry( Aig_Obj_t *, pGroup->vIns, pObj, i )
-        Aig_ObjSetTravIdCurrent( pGroup->pMan->pAig, pObj );
-    Vec_PtrForEachEntry( Aig_Obj_t *, pGroup->vOuts, pObj, i )
-        Aig_ObjSetTravIdPrevious( pGroup->pMan->pAig, pObj );
-    Vec_PtrForEachEntry( Aig_Obj_t *, pGroup->vOuts, pObj, i )
-        Llb_ManGroupCollect_rec( pGroup->pMan->pAig, pObj, vNodes );
-    return vNodes;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManGroupCreate_rec( Aig_Man_t * pAig, Aig_Obj_t * pObj, Vec_Ptr_t * vSupp )
-{ 
-    if ( Aig_ObjIsTravIdCurrent(pAig, pObj) )
-        return;
-    Aig_ObjSetTravIdCurrent(pAig, pObj);
-    if ( Aig_ObjIsConst1(pObj) )
-        return;
-    if ( pObj->fMarkA )
-    {
-        Vec_PtrPush( vSupp, pObj );
-        return;
-    }
-    assert( Aig_ObjIsAnd(pObj) );
-    Llb_ManGroupCreate_rec( pAig, Aig_ObjFanin0(pObj), vSupp );
-    Llb_ManGroupCreate_rec( pAig, Aig_ObjFanin1(pObj), vSupp );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Llb_Grp_t * Llb_ManGroupCreate( Llb_Man_t * pMan, Aig_Obj_t * pObj )
-{
-    Llb_Grp_t * p;
-    assert( pObj->fMarkA == 1 );
-    // derive group
-    p = Llb_ManGroupAlloc( pMan );
-    Vec_PtrPush( p->vOuts, pObj );
-    Aig_ManIncrementTravId( pMan->pAig );
-    if ( Aig_ObjIsCo(pObj) )
-        Llb_ManGroupCreate_rec( pMan->pAig, Aig_ObjFanin0(pObj), p->vIns );
-    else
-    {
-        Llb_ManGroupCreate_rec( pMan->pAig, Aig_ObjFanin0(pObj), p->vIns );
-        Llb_ManGroupCreate_rec( pMan->pAig, Aig_ObjFanin1(pObj), p->vIns );
-    }
-    // derive internal objects
-    assert( p->vNodes == NULL );
-    p->vNodes = Llb_ManGroupCollect( p );
-    return p;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Llb_Grp_t * Llb_ManGroupCreateFirst( Llb_Man_t * pMan )
-{
-    Llb_Grp_t * p;
-    Aig_Obj_t * pObj;
-    int i;
-    p = Llb_ManGroupAlloc( pMan );
-    Saig_ManForEachLo( pMan->pAig, pObj, i )
-        Vec_PtrPush( p->vOuts, pObj );
-    return p;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Llb_Grp_t * Llb_ManGroupCreateLast( Llb_Man_t * pMan )
-{
-    Llb_Grp_t * p;
-    Aig_Obj_t * pObj;
-    int i;
-    p = Llb_ManGroupAlloc( pMan );
-    Saig_ManForEachLi( pMan->pAig, pObj, i )
-        Vec_PtrPush( p->vIns, pObj );
-    return p;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Llb_Grp_t * Llb_ManGroupsCombine( Llb_Grp_t * p1, Llb_Grp_t * p2 )
-{
-    Llb_Grp_t * p;
-    Aig_Obj_t * pObj;
-    int i;
-    p = Llb_ManGroupAlloc( p1->pMan );
-    // create inputs
-    Vec_PtrForEachEntry( Aig_Obj_t *, p1->vIns, pObj, i )
-        Vec_PtrPush( p->vIns, pObj );
-    Vec_PtrForEachEntry( Aig_Obj_t *, p2->vIns, pObj, i )
-        Vec_PtrPushUnique( p->vIns, pObj );
-    // create outputs
-    Vec_PtrForEachEntry( Aig_Obj_t *, p1->vOuts, pObj, i )
-        Vec_PtrPush( p->vOuts, pObj );
-    Vec_PtrForEachEntry( Aig_Obj_t *, p2->vOuts, pObj, i )
-        Vec_PtrPushUnique( p->vOuts, pObj );
-
-    // derive internal objects
-    assert( p->vNodes == NULL );
-    p->vNodes = Llb_ManGroupCollect( p );
-    return p;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManGroupMarkNodes_rec( Aig_Man_t * p, Aig_Obj_t * pObj )
-{
-    if ( Aig_ObjIsTravIdCurrent(p, pObj) )
-        return;
-    if ( Aig_ObjIsTravIdPrevious(p, pObj) )
-    {
-        Aig_ObjSetTravIdCurrent(p, pObj);
-        return;
-    }
-    Aig_ObjSetTravIdCurrent(p, pObj);
-    assert( Aig_ObjIsNode(pObj) );
-    Llb_ManGroupMarkNodes_rec( p, Aig_ObjFanin0(pObj) );
-    Llb_ManGroupMarkNodes_rec( p, Aig_ObjFanin1(pObj) );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Creates group from two cuts derived by the flow computation.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Llb_Grp_t * Llb_ManGroupCreateFromCuts( Llb_Man_t * pMan, Vec_Int_t * vCut1, Vec_Int_t * vCut2 )
-{
-    Llb_Grp_t * p;
-    Aig_Obj_t * pObj;
-    int i;
-    p = Llb_ManGroupAlloc( pMan );
-
-    // mark Cut1
-    Aig_ManIncrementTravId( pMan->pAig );
-    Aig_ManForEachObjVec( vCut1, pMan->pAig, pObj, i )
-        Aig_ObjSetTravIdCurrent( pMan->pAig, pObj );
-    // collect unmarked Cut2
-    Aig_ManForEachObjVec( vCut2, pMan->pAig, pObj, i )
-        if ( !Aig_ObjIsTravIdCurrent( pMan->pAig, pObj ) )
-            Vec_PtrPush( p->vOuts, pObj );
-
-    // mark nodes reachable from Cut2
-    Aig_ManIncrementTravId( pMan->pAig );
-    Aig_ManForEachObjVec( vCut2, pMan->pAig, pObj, i )
-        Llb_ManGroupMarkNodes_rec( pMan->pAig, pObj );
-    // collect marked Cut1
-    Aig_ManForEachObjVec( vCut1, pMan->pAig, pObj, i )
-        if ( Aig_ObjIsTravIdCurrent( pMan->pAig, pObj ) )
-            Vec_PtrPush( p->vIns, pObj );
-
-    // derive internal objects
-    assert( p->vNodes == NULL );
-    p->vNodes = Llb_ManGroupCollect( p );
-    return p;
-}
-
-
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManPrepareGroups( Llb_Man_t * pMan )
-{
-    Aig_Obj_t * pObj;
-    int i;
-    assert( pMan->vGroups == NULL );
-    pMan->vGroups = Vec_PtrAlloc( 1000 );
-    Llb_ManGroupCreateFirst( pMan );
-    Aig_ManForEachNode( pMan->pAig, pObj, i )
-    {
-        if ( pObj->fMarkA )
-            Llb_ManGroupCreate( pMan, pObj );
-    }
-    Saig_ManForEachLi( pMan->pAig, pObj, i )
-    {
-        if ( pObj->fMarkA )
-            Llb_ManGroupCreate( pMan, pObj );
-    }
-    Llb_ManGroupCreateLast( pMan );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManPrintSpan( Llb_Man_t * p )
-{
-    Llb_Grp_t * pGroup;
-    Aig_Obj_t * pVar;
-    int i, k, Span = 0, SpanMax = 0;
-    Vec_PtrForEachEntry( Llb_Grp_t *, p->vGroups, pGroup, i )
-    {
-        Vec_PtrForEachEntry( Aig_Obj_t *, pGroup->vIns, pVar, k )
-            if ( Vec_IntEntry(p->vVarBegs, pVar->Id) == i )
-                Span++;
-        Vec_PtrForEachEntry( Aig_Obj_t *, pGroup->vOuts, pVar, k )
-            if ( Vec_IntEntry(p->vVarBegs, pVar->Id) == i )
-                Span++;
-
-        SpanMax = Abc_MaxInt( SpanMax, Span );
-printf( "%d ", Span );
-
-        Vec_PtrForEachEntry( Aig_Obj_t *, pGroup->vIns, pVar, k )
-            if ( Vec_IntEntry(p->vVarEnds, pVar->Id) == i )
-                Span--;
-        Vec_PtrForEachEntry( Aig_Obj_t *, pGroup->vOuts, pVar, k )
-            if ( Vec_IntEntry(p->vVarEnds, pVar->Id) == i )
-                Span--;
-    }
-printf( "\n" );
-printf( "Max = %d\n", SpanMax );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_ManGroupHasVar( Llb_Man_t * p, int iGroup, int iVar )
-{
-    Llb_Grp_t * pGroup = (Llb_Grp_t *)Vec_PtrEntry( p->vGroups, iGroup );
-    Aig_Obj_t * pObj;
-    int i;
-    Vec_PtrForEachEntry( Aig_Obj_t *, pGroup->vIns, pObj, i )
-        if ( pObj->Id == iVar )
-            return 1;
-    Vec_PtrForEachEntry( Aig_Obj_t *, pGroup->vOuts, pObj, i )
-        if ( pObj->Id == iVar )
-            return 1;
-    return 0;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManPrintHisto( Llb_Man_t * p )
-{
-    Aig_Obj_t * pObj;
-    int i, k;
-    Aig_ManForEachObj( p->pAig, pObj, i )
-    {
-        if ( Vec_IntEntry(p->vObj2Var, i) < 0 )
-            continue;
-        printf( "%3d :", i );
-        for ( k = 0; k < Vec_IntEntry(p->vVarBegs, i); k++ )
-            printf( " " );
-        for (      ; k <= Vec_IntEntry(p->vVarEnds, i); k++ )
-            printf( "%c", Llb_ManGroupHasVar(p, k, i)? '*':'-' );
-        printf( "\n" );
-    }
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/llb/llb1Hint.c b/src/proof/llb/llb1Hint.c
deleted file mode 100644
index 353b4c69..00000000
--- a/src/proof/llb/llb1Hint.c
+++ /dev/null
@@ -1,226 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [llb1Hint.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD based reachability.]
-
-  Synopsis    [Cofactors the circuit w.r.t. the high-fanout variables.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: llb1Hint.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "llbInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Returns CI index with the largest number of fanouts.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_ManMaxFanoutCi( Aig_Man_t * pAig )
-{
-    Aig_Obj_t * pObj; 
-    int i, WeightMax = -ABC_INFINITY, iInput = -1;
-    Aig_ManForEachCi( pAig, pObj, i )
-        if ( WeightMax < Aig_ObjRefs(pObj) )
-        {
-            WeightMax = Aig_ObjRefs(pObj);
-            iInput = i;
-        }
-    assert( iInput >= 0 );
-    return iInput;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Derives AIG whose PI is substituted by a constant.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Aig_Man_t * Llb_ManPerformHints( Aig_Man_t * pAig, int nHintDepth )
-{
-    Aig_Man_t * pNew, * pTemp;
-    int i, iInput;
-    pNew = Aig_ManDupDfs( pAig );
-    for ( i = 0; i < nHintDepth; i++ )
-    {
-        iInput = Llb_ManMaxFanoutCi( pNew );
-        Abc_Print( 1, "%d %3d\n", i, iInput );
-        pNew = Aig_ManDupCof( pTemp = pNew, iInput, 1 );
-        Aig_ManStop( pTemp );
-    }
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns CI index with the largest number of fanouts.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Int_t * Llb_ManCollectHighFanoutObjects( Aig_Man_t * pAig, int nCandMax, int fCisOnly )
-{
-    Vec_Int_t * vFanouts, * vResult;
-    Aig_Obj_t * pObj; 
-    int i, fChanges, PivotValue;
-//    int Entry;
-    // collect fanout counts
-    vFanouts = Vec_IntAlloc( 100 );
-    Aig_ManForEachObj( pAig, pObj, i )
-    {
-//        if ( !Aig_ObjIsCi(pObj) && (fCisOnly || !Aig_ObjIsNode(pObj)) )
-        if ( !Saig_ObjIsLo(pAig,pObj) && (fCisOnly || !Aig_ObjIsNode(pObj)) )
-            continue;
-        Vec_IntPush( vFanouts, Aig_ObjRefs(pObj) );
-    }
-    Vec_IntSort( vFanouts, 1 );
-    // pick the separator
-    nCandMax = Abc_MinInt( nCandMax, Vec_IntSize(vFanouts) - 1 );
-    PivotValue = Vec_IntEntry( vFanouts, nCandMax );
-    Vec_IntFree( vFanouts );
-    // collect obj satisfying the constraints
-    vResult = Vec_IntAlloc( 100 );
-    Aig_ManForEachObj( pAig, pObj, i )
-    {
-//        if ( !Aig_ObjIsCi(pObj) && (fCisOnly || !Aig_ObjIsNode(pObj)) )
-        if ( !Saig_ObjIsLo(pAig,pObj) && (fCisOnly || !Aig_ObjIsNode(pObj)) )
-            continue;
-        if ( Aig_ObjRefs(pObj) < PivotValue )
-            continue;
-        Vec_IntPush( vResult, Aig_ObjId(pObj) );
-    }
-    assert( Vec_IntSize(vResult) >= nCandMax );
-    // order in the decreasing order of fanouts
-    do
-    {
-        fChanges = 0;
-        for ( i = 0; i < Vec_IntSize(vResult) - 1; i++ )
-            if ( Aig_ObjRefs(Aig_ManObj(pAig, Vec_IntEntry(vResult, i))) < 
-                 Aig_ObjRefs(Aig_ManObj(pAig, Vec_IntEntry(vResult, i+1))) )
-            {
-                int Temp = Vec_IntEntry( vResult, i );
-                Vec_IntWriteEntry( vResult, i, Vec_IntEntry(vResult, i+1) );
-                Vec_IntWriteEntry( vResult, i+1, Temp );
-                fChanges = 1;
-            }
-    }
-    while ( fChanges );
-/*
-    Vec_IntForEachEntry( vResult, Entry, i )
-        printf( "%d ", Aig_ObjRefs(Aig_ManObj(pAig, Entry)) );
-printf( "\n" );
-*/
-    return vResult;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Derives AIG whose PI is substituted by a constant.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_ManModelCheckAigWithHints( Aig_Man_t * pAigGlo, Gia_ParLlb_t * pPars )
-{
-    DdManager * ddGlo = NULL;
-    Vec_Int_t * vHints;
-    Vec_Int_t * vHFCands;
-    int i, Entry, RetValue = -1;
-    abctime clk = Abc_Clock();
-    assert( pPars->nHintDepth > 0 );
-/*
-    // perform reachability without hints
-    RetValue = Llb_ManModelCheckAig( pAigGlo, pPars, NULL, NULL );
-    if ( RetValue >= 0 )
-        return RetValue;
-*/
-    // create hints representation
-    vHFCands = Llb_ManCollectHighFanoutObjects( pAigGlo, pPars->nHintDepth+pPars->HintFirst, 1 );
-    vHints   = Vec_IntStartFull( Aig_ManObjNumMax(pAigGlo) );
-    // add one hint at a time till the problem is solved
-    Vec_IntForEachEntryStart( vHFCands, Entry, i, pPars->HintFirst )
-    {
-        Vec_IntWriteEntry( vHints, Entry, 1 );   // change to 1 to start from zero cof!!!
-        // solve under hints
-        RetValue = Llb_ManModelCheckAig( pAigGlo, pPars, vHints, &ddGlo );
-        if ( RetValue == 0 )
-            goto Finish;
-        if ( RetValue == 1 )
-            break;
-    }
-    if ( RetValue == -1 )
-        goto Finish;
-    // undo the hints one at a time
-    for ( ; i >= pPars->HintFirst; i-- )
-    {
-        Entry = Vec_IntEntry( vHFCands, i );
-        Vec_IntWriteEntry( vHints, Entry, -1 );        
-        // solve under relaxed hints
-        RetValue = Llb_ManModelCheckAig( pAigGlo, pPars, vHints, &ddGlo );
-        if ( RetValue == 0 )
-            goto Finish;
-        if ( RetValue == 1 )
-            continue;
-        break;
-    }
-Finish:
-    if ( ddGlo )
-    {
-        if ( ddGlo->bFunc )
-            Cudd_RecursiveDeref( ddGlo, ddGlo->bFunc ); 
-        Extra_StopManager( ddGlo );
-    }
-    Vec_IntFreeP( &vHFCands );
-    Vec_IntFreeP( &vHints );
-    if ( pPars->fVerbose )
-        Abc_PrintTime( 1, "Total runtime", Abc_Clock() - clk );
-    return RetValue;
-}
-
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/llb/llb1Man.c b/src/proof/llb/llb1Man.c
deleted file mode 100644
index f5de25e0..00000000
--- a/src/proof/llb/llb1Man.c
+++ /dev/null
@@ -1,218 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [llb1Man.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD based reachability.]
-
-  Synopsis    [Reachability manager.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: llb1Man.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "llbInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManPrepareVarMap( Llb_Man_t * p )
-{
-    Aig_Obj_t * pObjLi, * pObjLo;
-    int i, iVarLi, iVarLo;
-    assert( p->vNs2Glo == NULL );
-    assert( p->vCs2Glo == NULL );
-    assert( p->vGlo2Cs == NULL );
-    assert( p->vGlo2Ns == NULL );
-    p->vNs2Glo = Vec_IntStartFull( Vec_IntSize(p->vVar2Obj) );
-    p->vCs2Glo = Vec_IntStartFull( Vec_IntSize(p->vVar2Obj) );
-    p->vGlo2Cs = Vec_IntStartFull( Aig_ManRegNum(p->pAig) );
-    p->vGlo2Ns = Vec_IntStartFull( Aig_ManRegNum(p->pAig) );
-    Saig_ManForEachLiLo( p->pAig, pObjLi, pObjLo, i )
-    {
-        iVarLi = Vec_IntEntry(p->vObj2Var, Aig_ObjId(pObjLi));
-        iVarLo = Vec_IntEntry(p->vObj2Var, Aig_ObjId(pObjLo));
-        assert( iVarLi >= 0 && iVarLi < Vec_IntSize(p->vVar2Obj) );
-        assert( iVarLo >= 0 && iVarLo < Vec_IntSize(p->vVar2Obj) );
-        Vec_IntWriteEntry( p->vNs2Glo, iVarLi, i );
-        Vec_IntWriteEntry( p->vCs2Glo, iVarLo, i );
-        Vec_IntWriteEntry( p->vGlo2Cs, i, iVarLo );
-        Vec_IntWriteEntry( p->vGlo2Ns, i, iVarLi );
-    }
-    // add mapping of the PIs
-    Saig_ManForEachPi( p->pAig, pObjLo, i )
-    {
-        iVarLo = Vec_IntEntry(p->vObj2Var, Aig_ObjId(pObjLo));
-        Vec_IntWriteEntry( p->vCs2Glo, iVarLo, Aig_ManRegNum(p->pAig)+i );
-        Vec_IntWriteEntry( p->vNs2Glo, iVarLo, Aig_ManRegNum(p->pAig)+i );
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManPrepareVarLimits( Llb_Man_t * p )
-{
-    Llb_Grp_t * pGroup;
-    Aig_Obj_t * pVar;
-    int i, k;
-    assert( p->vVarBegs == NULL );
-    assert( p->vVarEnds == NULL );
-    p->vVarEnds = Vec_IntStart( Aig_ManObjNumMax(p->pAig) ); 
-    p->vVarBegs = Vec_IntStart( Aig_ManObjNumMax(p->pAig) ); 
-    Vec_IntFill( p->vVarBegs, Aig_ManObjNumMax(p->pAig), p->pMatrix->nCols );
-
-    for ( i = 0; i < p->pMatrix->nCols; i++ )
-    {
-        pGroup = p->pMatrix->pColGrps[i];
-
-        Vec_PtrForEachEntry( Aig_Obj_t *, pGroup->vIns, pVar, k )
-            if ( Vec_IntEntry(p->vVarBegs, pVar->Id) > i )
-                Vec_IntWriteEntry( p->vVarBegs, pVar->Id, i );
-        Vec_PtrForEachEntry( Aig_Obj_t *, pGroup->vOuts, pVar, k )
-            if ( Vec_IntEntry(p->vVarBegs, pVar->Id) > i )
-                Vec_IntWriteEntry( p->vVarBegs, pVar->Id, i );
-
-        Vec_PtrForEachEntry( Aig_Obj_t *, pGroup->vIns, pVar, k )
-            if ( Vec_IntEntry(p->vVarEnds, pVar->Id) < i )
-                Vec_IntWriteEntry( p->vVarEnds, pVar->Id, i );
-        Vec_PtrForEachEntry( Aig_Obj_t *, pGroup->vOuts, pVar, k )
-            if ( Vec_IntEntry(p->vVarEnds, pVar->Id) < i )
-                Vec_IntWriteEntry( p->vVarEnds, pVar->Id, i );
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManStop( Llb_Man_t * p )
-{
-    Llb_Grp_t * pGrp;
-    DdNode * bTemp;
-    int i;
-
-//    Vec_IntFreeP( &p->vMem );
-//    Vec_PtrFreeP( &p->vTops );
-//    Vec_PtrFreeP( &p->vBots );
-//    Vec_VecFreeP( (Vec_Vec_t **)&p->vCuts );
-
-    if ( p->pMatrix )
-        Llb_MtrFree( p->pMatrix );
-    Vec_PtrForEachEntry( Llb_Grp_t *, p->vGroups, pGrp, i )
-        Llb_ManGroupStop( pGrp );
-    if ( p->dd )
-    {
-//        printf( "Manager dd\n" );
-        Extra_StopManager( p->dd );
-    }
-    if ( p->ddG )
-    {
-//        printf( "Manager ddG\n" );
-        if ( p->ddG->bFunc )
-            Cudd_RecursiveDeref( p->ddG, p->ddG->bFunc ); 
-        Extra_StopManager( p->ddG );
-    }
-    if ( p->ddR )
-    {
-//        printf( "Manager ddR\n" );
-        if ( p->ddR->bFunc )
-            Cudd_RecursiveDeref( p->ddR, p->ddR->bFunc ); 
-        Vec_PtrForEachEntry( DdNode *, p->vRings, bTemp, i )
-            Cudd_RecursiveDeref( p->ddR, bTemp );
-        Extra_StopManager( p->ddR );
-    }
-    Aig_ManStop( p->pAig );
-    Vec_PtrFreeP( &p->vGroups );
-    Vec_IntFreeP( &p->vVar2Obj );
-    Vec_IntFreeP( &p->vObj2Var );
-    Vec_IntFreeP( &p->vVarBegs );
-    Vec_IntFreeP( &p->vVarEnds );
-    Vec_PtrFreeP( &p->vRings  );
-    Vec_IntFreeP( &p->vNs2Glo );
-    Vec_IntFreeP( &p->vCs2Glo );
-    Vec_IntFreeP( &p->vGlo2Cs );
-    Vec_IntFreeP( &p->vGlo2Ns );
-//    Vec_IntFreeP( &p->vHints );
-    ABC_FREE( p );
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Llb_Man_t * Llb_ManStart( Aig_Man_t * pAigGlo, Aig_Man_t * pAig, Gia_ParLlb_t * pPars )
-{
-    Llb_Man_t * p;
-    Aig_ManCleanMarkA( pAig );
-    p = ABC_CALLOC( Llb_Man_t, 1 );
-    p->pAigGlo  = pAigGlo;
-    p->pPars    = pPars;
-    p->pAig     = pAig;
-    p->vVar2Obj = Llb_ManMarkPivotNodes( p->pAig, pPars->fUsePivots );
-    p->vObj2Var = Vec_IntInvert( p->vVar2Obj, -1 );
-    p->vRings   = Vec_PtrAlloc( 100 );
-    Llb_ManPrepareVarMap( p );
-    Llb_ManPrepareGroups( p );
-    Aig_ManCleanMarkA( pAig );
-    p->pMatrix = Llb_MtrCreate( p );
-    p->pMatrix->pMan = p;
-    return p;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/llb/llb1Matrix.c b/src/proof/llb/llb1Matrix.c
deleted file mode 100644
index 7aa9c744..00000000
--- a/src/proof/llb/llb1Matrix.c
+++ /dev/null
@@ -1,430 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [llb1Matrix.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD based reachability.]
-
-  Synopsis    [Partition clustering as a matrix problem.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: llb1Matrix.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "llbInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-//              0123              nCols
-//             +--------------------->  
-// pi        0 |  111             row0   pRowSums[0]  
-// pi        1 | 1     11         row1   pRowSums[1] 
-// pi        2 |   1  11          row2   pRowSums[2] 
-// CS          |1       1
-// CS          |1      111
-// CS          |111    111
-// int         |  11111           
-// int         |     111          
-// int         |       111        
-// int         |         111      
-// NS          |           11 11
-// NS          |            11 1
-// NS          |             111
-//       nRows |
-//             v    
-//              cccc   pColSums[0]
-//              oooo   pColSums[1]
-//              llll   pColSums[2]
-//              0123   pColSums[3]
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Verify columns.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_MtrVerifyRowsAll( Llb_Mtr_t * p )
-{
-    int iRow, iCol, Counter;
-    for ( iCol = 0; iCol < p->nCols; iCol++ )
-    {
-        Counter = 0;
-        for ( iRow = 0; iRow < p->nRows; iRow++ )
-            if ( p->pMatrix[iCol][iRow] == 1 )
-                Counter++;
-        assert( Counter == p->pColSums[iCol] );
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Verify columns.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_MtrVerifyColumnsAll( Llb_Mtr_t * p )
-{
-    int iRow, iCol, Counter;
-    for ( iRow = 0; iRow < p->nRows; iRow++ )
-    {
-        Counter = 0;
-        for ( iCol = 0; iCol < p->nCols; iCol++ )
-            if ( p->pMatrix[iCol][iRow] == 1 )
-                Counter++;
-        assert( Counter == p->pRowSums[iRow] );
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Verify columns.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_MtrVerifyMatrix( Llb_Mtr_t * p )
-{
-    Llb_MtrVerifyRowsAll( p );
-    Llb_MtrVerifyColumnsAll( p );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Sort variables in the order of removal.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int * Llb_MtrFindVarOrder( Llb_Mtr_t * p )
-{
-    int * pOrder, * pLast;
-    int i, k, fChanges, Temp;
-    pOrder = ABC_CALLOC( int, p->nRows );
-    pLast  = ABC_CALLOC( int, p->nRows );
-    for ( i = 0; i < p->nRows; i++ )
-    {
-        pOrder[i] = i;
-        for ( k = p->nCols - 1; k >= 0; k-- )
-            if ( p->pMatrix[k][i] )
-            {
-                pLast[i] = k;
-                break;
-            }
-    }
-    do
-    {
-        fChanges = 0;
-        for ( i = 0; i < p->nRows - 1; i++ )
-            if ( pLast[i] > pLast[i+1] )
-            {
-                Temp = pOrder[i];
-                pOrder[i] = pOrder[i+1];
-                pOrder[i+1] = Temp;
-
-                Temp = pLast[i];
-                pLast[i] = pLast[i+1];
-                pLast[i+1] = Temp;
-
-                fChanges = 1;
-            }
-    }
-    while ( fChanges );
-    ABC_FREE( pLast );
-    return pOrder;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns type of a variable.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-char * Llb_MtrVarName( Llb_Mtr_t * p, int iVar )
-{
-    static char Buffer[10];
-    if ( iVar < p->nPis )
-        strcpy( Buffer, "pi" );
-    else if ( iVar < p->nPis + p->nFfs )
-        strcpy( Buffer, "CS" );
-    else if ( iVar >= p->nRows - p->nFfs )
-        strcpy( Buffer, "NS" );
-    else 
-        strcpy( Buffer, "int" );
-    return Buffer;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Creates one column with vars in the array.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_MtrPrint( Llb_Mtr_t * p, int fOrder )
-{
-    int * pOrder = NULL;
-    int i, iRow, iCol;
-    if ( fOrder )
-        pOrder = Llb_MtrFindVarOrder( p );
-    for ( i = 0; i < p->nRows; i++ )
-    {
-        iRow = pOrder ? pOrder[i] : i;
-        printf( "%3d : ", iRow );
-        printf( "%3d ", p->pRowSums[iRow] );
-        printf( "%3s ", Llb_MtrVarName(p, iRow) );
-        for ( iCol = 0; iCol < p->nCols; iCol++ )
-            printf( "%c", p->pMatrix[iCol][iRow] ? '*' : ' ' );
-        printf( "\n" );
-    }
-    ABC_FREE( pOrder );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Verify columns.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_MtrPrintMatrixStats( Llb_Mtr_t * p )
-{
-    int iVar, iGrp, iGrp1, iGrp2, Span = 0, nCutSize = 0, nCutSizeMax = 0;
-    int * pGrp1 = ABC_CALLOC( int, p->nRows ); 
-    int * pGrp2 = ABC_CALLOC( int, p->nRows ); 
-    for ( iVar = 0; iVar < p->nRows; iVar++ )
-    {
-        if ( p->pRowSums[iVar] == 0 )
-            continue;
-        for ( iGrp1 = 0; iGrp1 < p->nCols; iGrp1++ )
-            if ( p->pMatrix[iGrp1][iVar] == 1 )
-                break;
-        for ( iGrp2 = p->nCols - 1; iGrp2 >= 0; iGrp2-- )
-            if ( p->pMatrix[iGrp2][iVar] == 1 )
-                break;
-        assert( iGrp1 <= iGrp2 );
-        pGrp1[iVar] = iGrp1;
-        pGrp2[iVar] = iGrp2;
-        Span += iGrp2 - iGrp1;
-    }
-    // compute span
-    for ( iGrp = 0; iGrp < p->nCols; iGrp++ )
-    {
-        for ( iVar = 0; iVar < p->nRows; iVar++ )
-            if ( pGrp1[iVar] == iGrp )
-                nCutSize++;
-        if ( nCutSizeMax < nCutSize )
-            nCutSizeMax = nCutSize;
-        for ( iVar = 0; iVar < p->nRows; iVar++ )
-            if ( pGrp2[iVar] == iGrp )
-                nCutSize--;
-    }
-    ABC_FREE( pGrp1 );
-    ABC_FREE( pGrp2 );
-    printf( "[%4d x %4d]  Life-span =%6.2f  Max-cut =%5d\n", 
-        p->nCols, p->nRows, 1.0*Span/p->nRows, nCutSizeMax );
-    if ( nCutSize )
-        Abc_Print( -1, "Cut size is not zero (%d).\n", nCutSize );
-}
-
-
-
-/**Function*************************************************************
-
-  Synopsis    [Starts the matrix representation.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Llb_Mtr_t * Llb_MtrAlloc( int nPis, int nFfs, int nCols, int nRows )
-{
-    Llb_Mtr_t * p;
-    int i;
-    p = ABC_CALLOC( Llb_Mtr_t, 1 );
-    p->nPis  = nPis;
-    p->nFfs  = nFfs;
-    p->nRows = nRows;
-    p->nCols = nCols;
-    p->pRowSums = ABC_CALLOC( int, nRows );
-    p->pColSums = ABC_CALLOC( int, nCols );
-    p->pColGrps = ABC_CALLOC( Llb_Grp_t *, nCols );
-    p->pMatrix  = ABC_CALLOC( char *, nCols );
-    for ( i = 0; i < nCols; i++ )
-        p->pMatrix[i] = ABC_CALLOC( char, nRows );
-    // partial product
-    p->pProdVars = ABC_CALLOC( char, nRows );  // variables in the partial product
-    p->pProdNums = ABC_CALLOC( int, nRows );   // var counts in the remaining partitions
-    return p;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Stops the matrix representation.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_MtrFree( Llb_Mtr_t * p )
-{
-    int i;
-    ABC_FREE( p->pProdVars );
-    ABC_FREE( p->pProdNums );
-    for ( i = 0; i < p->nCols; i++ )
-        ABC_FREE( p->pMatrix[i] );
-    ABC_FREE( p->pRowSums );
-    ABC_FREE( p->pColSums );
-    ABC_FREE( p->pMatrix );
-    ABC_FREE( p->pColGrps );
-    ABC_FREE( p );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Creates one column with vars in the array.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_MtrAddColumn( Llb_Mtr_t * p, Llb_Grp_t * pGrp )
-{
-    Aig_Obj_t * pVar;
-    int i, iRow, iCol = pGrp->Id;
-    assert( iCol >= 0 && iCol < p->nCols );
-    p->pColGrps[iCol] = pGrp;
-    Vec_PtrForEachEntry( Aig_Obj_t *, pGrp->vIns, pVar, i )
-    {
-        iRow = Vec_IntEntry( pGrp->pMan->vObj2Var, Aig_ObjId(pVar) );
-        assert( iRow >= 0 && iRow < p->nRows );
-        p->pMatrix[iCol][iRow] = 1;
-        p->pColSums[iCol]++;
-        p->pRowSums[iRow]++;
-    }
-    Vec_PtrForEachEntry( Aig_Obj_t *, pGrp->vOuts, pVar, i )
-    {
-        iRow = Vec_IntEntry( pGrp->pMan->vObj2Var, Aig_ObjId(pVar) );
-        assert( iRow >= 0 && iRow < p->nRows );
-        p->pMatrix[iCol][iRow] = 1;
-        p->pColSums[iCol]++;
-        p->pRowSums[iRow]++;
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Matrix reduce.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_MtrRemoveSingletonRows( Llb_Mtr_t * p )
-{
-    int i, k;
-    for ( i = 0; i < p->nRows; i++ )
-        if ( p->pRowSums[i] < 2 )
-        {
-            p->pRowSums[i] = 0;
-            for ( k = 0; k < p->nCols; k++ )
-            {
-                if ( p->pMatrix[k][i] == 1 )
-                {
-                    p->pMatrix[k][i] = 0;
-                    p->pColSums[k]--;
-                }
-            }
-        }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Matrix reduce.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Llb_Mtr_t * Llb_MtrCreate( Llb_Man_t * p )
-{
-    Llb_Mtr_t * pMatrix;
-    Llb_Grp_t * pGroup;
-    int i;
-    pMatrix = Llb_MtrAlloc( Saig_ManPiNum(p->pAig), Saig_ManRegNum(p->pAig), 
-        Vec_PtrSize(p->vGroups), Vec_IntSize(p->vVar2Obj) );
-    Vec_PtrForEachEntry( Llb_Grp_t *, p->vGroups, pGroup, i )
-        Llb_MtrAddColumn( pMatrix, pGroup );
-//    Llb_MtrRemoveSingletonRows( pMatrix );
-    return pMatrix;
-}
-
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/llb/llb1Pivot.c b/src/proof/llb/llb1Pivot.c
deleted file mode 100644
index 7a5bb66f..00000000
--- a/src/proof/llb/llb1Pivot.c
+++ /dev/null
@@ -1,254 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [llb1Pivot.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD based reachability.]
-
-  Synopsis    [Determining pivot variables.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: llb1Pivot.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "llbInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_ManTracePaths_rec( Aig_Man_t * p, Aig_Obj_t * pObj, Aig_Obj_t * pPivot )
-{
-    Aig_Obj_t * pFanout;
-    int k, iFan = -1;
-    if ( Aig_ObjIsTravIdPrevious(p, pObj) )
-        return 0;
-    if ( Aig_ObjIsTravIdCurrent(p, pObj) )
-        return 1;
-    if ( Saig_ObjIsLi(p, pObj) )
-        return 0;
-    if ( Saig_ObjIsPo(p, pObj) )
-        return 0;
-    if ( pObj == pPivot )
-        return 1;
-    assert( Aig_ObjIsCand(pObj) );
-    Aig_ObjForEachFanout( p, pObj, pFanout, iFan, k )
-        if ( !Llb_ManTracePaths_rec( p, pFanout, pPivot ) )
-        {
-            Aig_ObjSetTravIdPrevious(p, pObj);
-            return 0;
-        }
-    Aig_ObjSetTravIdCurrent(p, pObj);
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_ManTracePaths( Aig_Man_t * p, Aig_Obj_t * pPivot )
-{
-    Aig_Obj_t * pObj;
-    int i, Counter = 0;
-    Aig_ManIncrementTravId( p ); // prev = visited with path to LI  (value 0)
-    Aig_ManIncrementTravId( p ); // cur  = visited w/o  path to LI  (value 1)
-    Saig_ManForEachLo( p, pObj, i )
-        Counter += Llb_ManTracePaths_rec( p, pObj, pPivot );
-    return Counter;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManTestCuts( Aig_Man_t * p )
-{
-    Aig_Obj_t * pObj;
-    int i, Count;
-    Aig_ManFanoutStart( p );
-    Aig_ManForEachNode( p, pObj, i )
-    {
-        if ( Aig_ObjRefs(pObj) <= 1 )
-            continue;
-        Count = Llb_ManTracePaths( p, pObj );
-        printf( "Obj =%5d.  Lev =%3d.  Fanout =%5d.  Count = %3d.\n", 
-            i, Aig_ObjLevel(pObj), Aig_ObjRefs(pObj), Count );
-    }
-    Aig_ManFanoutStop( p );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManLabelLiCones_rec( Aig_Man_t * p, Aig_Obj_t * pObj )
-{
-    if ( pObj->fMarkB )
-        return;
-    pObj->fMarkB = 1;
-    assert( Aig_ObjIsNode(pObj) );
-    Llb_ManLabelLiCones_rec( p, Aig_ObjFanin0(pObj) );
-    Llb_ManLabelLiCones_rec( p, Aig_ObjFanin1(pObj) );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Determine starting cut-points.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManLabelLiCones( Aig_Man_t * p )
-{
-    Aig_Obj_t * pObj;
-    int i;
-    // mark const and PIs
-    Aig_ManConst1(p)->fMarkB = 1;
-    Aig_ManForEachCi( p, pObj, i )
-        pObj->fMarkB = 1;
-    // mark cones
-    Saig_ManForEachLi( p, pObj, i )
-        Llb_ManLabelLiCones_rec( p, Aig_ObjFanin0(pObj) );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Determine starting cut-points.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManMarkInternalPivots( Aig_Man_t * p )
-{
-    Vec_Ptr_t * vMuxes;
-    Aig_Obj_t * pObj;
-    int i, Counter = 0;
-
-    // remove refs due to MUXes
-    vMuxes = Aig_ManMuxesCollect( p );
-    Aig_ManMuxesDeref( p, vMuxes );
-
-    // mark nodes feeding into LIs
-    Aig_ManCleanMarkB( p );
-    Llb_ManLabelLiCones( p );
-
-    // mark internal nodes
-    Aig_ManFanoutStart( p );
-    Aig_ManForEachNode( p, pObj, i )
-        if ( pObj->fMarkB && pObj->nRefs > 1 )
-        {
-            if ( Llb_ManTracePaths(p, pObj) > 0 )
-                pObj->fMarkA = 1;
-            Counter++;
-        }
-    Aig_ManFanoutStop( p );
-//    printf( "TracePath tried = %d.\n", Counter );
-
-    // mark nodes feeding into LIs
-    Aig_ManCleanMarkB( p );
-
-    // add refs due to MUXes
-    Aig_ManMuxesRef( p, vMuxes );
-    Vec_PtrFree( vMuxes );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Determine starting cut-points.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Int_t * Llb_ManMarkPivotNodes( Aig_Man_t * p, int fUseInternal )
-{
-    Vec_Int_t * vVar2Obj;
-    Aig_Obj_t * pObj;
-    int i;
-    // mark inputs/outputs
-    Aig_ManForEachCi( p, pObj, i )
-        pObj->fMarkA = 1;
-    Saig_ManForEachLi( p, pObj, i )
-        pObj->fMarkA = 1;
-
-    // mark internal pivot nodes
-    if ( fUseInternal )
-        Llb_ManMarkInternalPivots( p );
-
-    // assign variable numbers
-    Aig_ManConst1(p)->fMarkA = 0;
-    vVar2Obj = Vec_IntAlloc( 100 );
-    Aig_ManForEachCi( p, pObj, i )
-        Vec_IntPush( vVar2Obj, Aig_ObjId(pObj) );
-    Aig_ManForEachNode( p, pObj, i )
-        if ( pObj->fMarkA )
-            Vec_IntPush( vVar2Obj, Aig_ObjId(pObj) );
-    Saig_ManForEachLi( p, pObj, i )
-        Vec_IntPush( vVar2Obj, Aig_ObjId(pObj) );
-    return vVar2Obj;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/llb/llb1Reach.c b/src/proof/llb/llb1Reach.c
deleted file mode 100644
index fae7bee2..00000000
--- a/src/proof/llb/llb1Reach.c
+++ /dev/null
@@ -1,904 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [llb1Reach.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD based reachability.]
-
-  Synopsis    [Reachability analysis.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: llb1Reach.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "llbInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
- 
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Derives global BDD for the node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb_ManConstructOutBdd( Aig_Man_t * pAig, Aig_Obj_t * pNode, DdManager * dd )
-{
-    DdNode * bBdd0, * bBdd1, * bFunc;
-    Vec_Ptr_t * vNodes;
-    Aig_Obj_t * pObj = NULL;
-    int i;
-    abctime TimeStop;
-    if ( Aig_ObjFanin0(pNode) == Aig_ManConst1(pAig) )
-        return Cudd_NotCond( Cudd_ReadOne(dd), Aig_ObjFaninC0(pNode) );
-    TimeStop = dd->TimeStop;  dd->TimeStop = 0;
-    vNodes = Aig_ManDfsNodes( pAig, &pNode, 1 );
-    assert( Vec_PtrSize(vNodes) > 0 );
-    Vec_PtrForEachEntry( Aig_Obj_t *, vNodes, pObj, i )
-    {
-        if ( !Aig_ObjIsNode(pObj) )
-            continue;
-        bBdd0 = Cudd_NotCond( Aig_ObjFanin0(pObj)->pData, Aig_ObjFaninC0(pObj) );
-        bBdd1 = Cudd_NotCond( Aig_ObjFanin1(pObj)->pData, Aig_ObjFaninC1(pObj) );
-        pObj->pData = Cudd_bddAnd( dd, bBdd0, bBdd1 );  Cudd_Ref( (DdNode *)pObj->pData );
-    }
-    bFunc = (DdNode *)pObj->pData; Cudd_Ref( bFunc );
-    Vec_PtrForEachEntry( Aig_Obj_t *, vNodes, pObj, i )
-    {
-        if ( !Aig_ObjIsNode(pObj) )
-            continue;
-        Cudd_RecursiveDeref( dd, (DdNode *)pObj->pData );
-    }
-    Vec_PtrFree( vNodes );
-    if ( Aig_ObjIsCo(pNode) )
-        bFunc = Cudd_NotCond( bFunc, Aig_ObjFaninC0(pNode) );
-    Cudd_Deref( bFunc );
-    dd->TimeStop = TimeStop;
-    return bFunc;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Derives BDD for the group.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb_ManConstructGroupBdd( Llb_Man_t * p, Llb_Grp_t * pGroup )
-{
-    Aig_Obj_t * pObj;
-    DdNode * bBdd0, * bBdd1, * bRes, * bXor, * bTemp;
-    int i, k;
-    Aig_ManConst1(p->pAig)->pData = Cudd_ReadOne( p->dd );
-    Vec_PtrForEachEntry( Aig_Obj_t *, pGroup->vIns, pObj, i )
-        pObj->pData = Cudd_bddIthVar( p->dd, Vec_IntEntry(p->vObj2Var, Aig_ObjId(pObj)) );
-    Vec_PtrForEachEntry( Aig_Obj_t *, pGroup->vNodes, pObj, i )
-    {
-        bBdd0 = Cudd_NotCond( Aig_ObjFanin0(pObj)->pData, Aig_ObjFaninC0(pObj) );
-        bBdd1 = Cudd_NotCond( Aig_ObjFanin1(pObj)->pData, Aig_ObjFaninC1(pObj) );
-//        pObj->pData = Extra_bddAndTime( p->dd, bBdd0, bBdd1, p->pPars->TimeTarget );  
-        pObj->pData = Cudd_bddAnd( p->dd, bBdd0, bBdd1 );  
-        if ( pObj->pData == NULL )
-        {
-            Vec_PtrForEachEntryStop( Aig_Obj_t *, pGroup->vNodes, pObj, k, i )
-                if ( pObj->pData )
-                    Cudd_RecursiveDeref( p->dd, (DdNode *)pObj->pData );
-            return NULL;
-        }
-        Cudd_Ref( (DdNode *)pObj->pData );
-    }
-    bRes = Cudd_ReadOne( p->dd );   Cudd_Ref( bRes );
-    Vec_PtrForEachEntry( Aig_Obj_t *, pGroup->vOuts, pObj, i )
-    {
-        if ( Aig_ObjIsCo(pObj) )
-            bBdd0 = Cudd_NotCond( Aig_ObjFanin0(pObj)->pData, Aig_ObjFaninC0(pObj) );
-        else
-            bBdd0 = (DdNode *)pObj->pData;
-        bBdd1 = Cudd_bddIthVar( p->dd, Vec_IntEntry(p->vObj2Var, Aig_ObjId(pObj)) );
-        bXor  = Cudd_bddXor( p->dd, bBdd0, bBdd1 );                  Cudd_Ref( bXor );
-//        bRes  = Extra_bddAndTime( p->dd, bTemp = bRes, Cudd_Not(bXor), p->pPars->TimeTarget );  
-        bRes  = Cudd_bddAnd( p->dd, bTemp = bRes, Cudd_Not(bXor) );  
-        if ( bRes == NULL )
-        {
-            Cudd_RecursiveDeref( p->dd, bTemp );
-            Cudd_RecursiveDeref( p->dd, bXor );
-            Vec_PtrForEachEntryStop( Aig_Obj_t *, pGroup->vNodes, pObj, k, i )
-                if ( pObj->pData )
-                    Cudd_RecursiveDeref( p->dd, (DdNode *)pObj->pData );
-            return NULL;
-        }        
-        Cudd_Ref( bRes );
-        Cudd_RecursiveDeref( p->dd, bTemp );
-        Cudd_RecursiveDeref( p->dd, bXor );
-    }
-    Vec_PtrForEachEntry( Aig_Obj_t *, pGroup->vNodes, pObj, i )
-        Cudd_RecursiveDeref( p->dd, (DdNode *)pObj->pData );
-    Cudd_Deref( bRes );
-    return bRes;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Derives quantification cube.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb_ManConstructQuantCubeIntern( Llb_Man_t * p, Llb_Grp_t * pGroup, int iGrpPlace, int fBackward )
-{
-    Aig_Obj_t * pObj;
-    DdNode * bRes, * bTemp, * bVar;
-    int i, iGroupFirst, iGroupLast;
-    abctime TimeStop;
-    TimeStop = p->dd->TimeStop; p->dd->TimeStop = 0;
-    bRes = Cudd_ReadOne( p->dd );   Cudd_Ref( bRes );
-    Vec_PtrForEachEntry( Aig_Obj_t *, pGroup->vIns, pObj, i )
-    {
-        if ( fBackward && Saig_ObjIsPi(p->pAig, pObj) )
-            continue;
-        iGroupFirst = Vec_IntEntry(p->vVarBegs, Aig_ObjId(pObj));
-        iGroupLast  = Vec_IntEntry(p->vVarEnds, Aig_ObjId(pObj));
-        assert( iGroupFirst <= iGroupLast );
-        if ( iGroupFirst < iGroupLast )
-            continue;
-        bVar  = Cudd_bddIthVar( p->dd, Vec_IntEntry(p->vObj2Var, Aig_ObjId(pObj)) );
-        bRes  = Cudd_bddAnd( p->dd, bTemp = bRes, bVar );  Cudd_Ref( bRes );
-        Cudd_RecursiveDeref( p->dd, bTemp );
-    }
-    Vec_PtrForEachEntry( Aig_Obj_t *, pGroup->vOuts, pObj, i )
-    {
-        if ( fBackward && Saig_ObjIsPi(p->pAig, pObj) )
-            continue;
-        iGroupFirst = Vec_IntEntry(p->vVarBegs, Aig_ObjId(pObj));
-        iGroupLast  = Vec_IntEntry(p->vVarEnds, Aig_ObjId(pObj));
-        assert( iGroupFirst <= iGroupLast );
-        if ( iGroupFirst < iGroupLast )
-            continue;
-        bVar  = Cudd_bddIthVar( p->dd, Vec_IntEntry(p->vObj2Var, Aig_ObjId(pObj)) );
-        bRes  = Cudd_bddAnd( p->dd, bTemp = bRes, bVar );  Cudd_Ref( bRes );
-        Cudd_RecursiveDeref( p->dd, bTemp );
-    }
-    Cudd_Deref( bRes );
-    p->dd->TimeStop = TimeStop;
-    return bRes;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Derives quantification cube.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb_ManConstructQuantCubeFwd( Llb_Man_t * p, Llb_Grp_t * pGroup, int iGrpPlace )
-{
-    Aig_Obj_t * pObj;
-    DdNode * bRes, * bTemp, * bVar;
-    int i, iGroupLast;
-    abctime TimeStop;
-    TimeStop = p->dd->TimeStop; p->dd->TimeStop = 0;
-    bRes = Cudd_ReadOne( p->dd );   Cudd_Ref( bRes );
-    Vec_PtrForEachEntry( Aig_Obj_t *, pGroup->vIns, pObj, i )
-    {
-        iGroupLast = Vec_IntEntry(p->vVarEnds, Aig_ObjId(pObj));
-        assert( iGroupLast >= iGrpPlace );
-        if ( iGroupLast > iGrpPlace )
-            continue;
-        bVar  = Cudd_bddIthVar( p->dd, Vec_IntEntry(p->vObj2Var, Aig_ObjId(pObj)) );
-        bRes  = Cudd_bddAnd( p->dd, bTemp = bRes, bVar );  Cudd_Ref( bRes );
-        Cudd_RecursiveDeref( p->dd, bTemp );
-    }
-    Vec_PtrForEachEntry( Aig_Obj_t *, pGroup->vOuts, pObj, i )
-    {
-        iGroupLast = Vec_IntEntry(p->vVarEnds, Aig_ObjId(pObj));
-        assert( iGroupLast >= iGrpPlace );
-        if ( iGroupLast > iGrpPlace )
-            continue;
-        bVar  = Cudd_bddIthVar( p->dd, Vec_IntEntry(p->vObj2Var, Aig_ObjId(pObj)) );
-        bRes  = Cudd_bddAnd( p->dd, bTemp = bRes, bVar );  Cudd_Ref( bRes );
-        Cudd_RecursiveDeref( p->dd, bTemp );
-    }
-    Cudd_Deref( bRes );
-    p->dd->TimeStop = TimeStop;
-    return bRes;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Derives quantification cube.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb_ManConstructQuantCubeBwd( Llb_Man_t * p, Llb_Grp_t * pGroup, int iGrpPlace )
-{
-    Aig_Obj_t * pObj;
-    DdNode * bRes, * bTemp, * bVar;
-    int i, iGroupFirst;
-    abctime TimeStop;
-    TimeStop = p->dd->TimeStop; p->dd->TimeStop = 0;
-    bRes = Cudd_ReadOne( p->dd );   Cudd_Ref( bRes );
-    Vec_PtrForEachEntry( Aig_Obj_t *, pGroup->vIns, pObj, i )
-    {
-        if ( Saig_ObjIsPi(p->pAig, pObj) )
-            continue;
-        iGroupFirst = Vec_IntEntry(p->vVarBegs, Aig_ObjId(pObj));
-        assert( iGroupFirst <= iGrpPlace );
-        if ( iGroupFirst < iGrpPlace )
-            continue;
-        bVar  = Cudd_bddIthVar( p->dd, Vec_IntEntry(p->vObj2Var, Aig_ObjId(pObj)) );
-        bRes  = Cudd_bddAnd( p->dd, bTemp = bRes, bVar );  Cudd_Ref( bRes );
-        Cudd_RecursiveDeref( p->dd, bTemp );
-    }
-    Vec_PtrForEachEntry( Aig_Obj_t *, pGroup->vOuts, pObj, i )
-    {
-        if ( Saig_ObjIsPi(p->pAig, pObj) )
-            continue;
-        iGroupFirst = Vec_IntEntry(p->vVarBegs, Aig_ObjId(pObj));
-        assert( iGroupFirst <= iGrpPlace );
-        if ( iGroupFirst < iGrpPlace )
-            continue;
-        bVar  = Cudd_bddIthVar( p->dd, Vec_IntEntry(p->vObj2Var, Aig_ObjId(pObj)) );
-        bRes  = Cudd_bddAnd( p->dd, bTemp = bRes, bVar );  Cudd_Ref( bRes );
-        Cudd_RecursiveDeref( p->dd, bTemp );
-    }
-    Cudd_Deref( bRes );
-    p->dd->TimeStop = TimeStop;
-    return bRes;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb_ManComputeInitState( Llb_Man_t * p, DdManager * dd )
-{
-    Aig_Obj_t * pObj;
-    DdNode * bRes, * bVar, * bTemp;
-    int i, iVar;
-    abctime TimeStop;
-    TimeStop = dd->TimeStop; dd->TimeStop = 0;
-    bRes = Cudd_ReadOne( dd );   Cudd_Ref( bRes );
-    Saig_ManForEachLo( p->pAig, pObj, i )
-    {
-        iVar  = (dd == p->ddG) ? i : Vec_IntEntry(p->vObj2Var, Aig_ObjId(pObj));
-        bVar  = Cudd_bddIthVar( dd, iVar );
-        bRes  = Cudd_bddAnd( dd, bTemp = bRes, Cudd_Not(bVar) );  Cudd_Ref( bRes );
-        Cudd_RecursiveDeref( dd, bTemp );
-    }
-    Cudd_Deref( bRes );
-    dd->TimeStop = TimeStop;
-    return bRes;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb_ManComputeImage( Llb_Man_t * p, DdNode * bInit, int fBackward )
-{
-    int fCheckSupport = 0;
-    Llb_Grp_t * pGroup;
-    DdNode * bImage, * bGroup, * bCube, * bTemp;
-    int k, Index;
-    bImage = bInit;  Cudd_Ref( bImage );
-    for ( k = 1; k < p->pMatrix->nCols-1; k++ )
-    {
-        if ( fBackward )
-            Index = p->pMatrix->nCols - 1 - k;
-        else
-            Index = k;
-
-        // compute group BDD
-        pGroup = p->pMatrix->pColGrps[Index];
-        bGroup = Llb_ManConstructGroupBdd( p, pGroup );
-        if ( bGroup == NULL )
-        {
-            Cudd_RecursiveDeref( p->dd, bImage );
-            return NULL;
-        }
-        Cudd_Ref( bGroup );
-        // quantify variables appearing only in this group
-        bCube  = Llb_ManConstructQuantCubeIntern( p, pGroup, Index, fBackward );       Cudd_Ref( bCube );
-        bGroup = Cudd_bddExistAbstract( p->dd, bTemp = bGroup, bCube );         
-        if ( bGroup == NULL )
-        {
-            Cudd_RecursiveDeref( p->dd, bTemp );
-            Cudd_RecursiveDeref( p->dd, bCube );
-            return NULL;
-        }
-        Cudd_Ref( bGroup );
-        Cudd_RecursiveDeref( p->dd, bTemp );
-        Cudd_RecursiveDeref( p->dd, bCube );
-        // perform partial product
-        if ( fBackward )
-            bCube  = Llb_ManConstructQuantCubeBwd( p, pGroup, Index );
-        else
-            bCube  = Llb_ManConstructQuantCubeFwd( p, pGroup, Index );
-        Cudd_Ref( bCube );
-//        bImage = Extra_bddAndAbstractTime( p->dd, bTemp = bImage, bGroup, bCube, p->pPars->TimeTarget );   
-        bImage = Cudd_bddAndAbstract( p->dd, bTemp = bImage, bGroup, bCube );   
-        if ( bImage == NULL )
-        {
-            Cudd_RecursiveDeref( p->dd, bTemp );
-            Cudd_RecursiveDeref( p->dd, bGroup );
-            Cudd_RecursiveDeref( p->dd, bCube );
-            return NULL;
-        }
-        Cudd_Ref( bImage );
-        Cudd_RecursiveDeref( p->dd, bTemp );
-        Cudd_RecursiveDeref( p->dd, bGroup );
-        Cudd_RecursiveDeref( p->dd, bCube );
-    }
-
-    // make sure image depends on next state vars
-    if ( fCheckSupport )
-    {
-        bCube = Cudd_Support( p->dd, bImage );    Cudd_Ref( bCube );
-        for ( bTemp = bCube; bTemp != p->dd->one; bTemp = cuddT(bTemp) )
-        {
-            int ObjId = Vec_IntEntry( p->vVar2Obj, bTemp->index );
-            Aig_Obj_t * pObj = Aig_ManObj( p->pAig, ObjId );
-            if ( !Saig_ObjIsLi(p->pAig, pObj) )
-                printf( "Var %d assigned to obj %d that is not LI\n", bTemp->index, ObjId );
-        }
-        Cudd_RecursiveDeref( p->dd, bCube );
-    }
-    Cudd_Deref( bImage );
-    return bImage;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb_ManCreateConstraints( Llb_Man_t * p, Vec_Int_t * vHints, int fUseNsVars )
-{
-    DdNode * bConstr, * bFunc, * bTemp;
-    Aig_Obj_t * pObj;
-    int i, Entry;
-    abctime TimeStop;
-    if ( vHints == NULL )
-        return Cudd_ReadOne( p->dd );
-    TimeStop = p->dd->TimeStop; p->dd->TimeStop = 0;
-    assert( Aig_ManCiNum(p->pAig) == Aig_ManCiNum(p->pAigGlo) );
-    // assign const and PI nodes to the original AIG
-    Aig_ManCleanData( p->pAig );
-    Aig_ManConst1( p->pAig )->pData = Cudd_ReadOne( p->dd );
-    Saig_ManForEachPi( p->pAig, pObj, i )
-        pObj->pData = Cudd_bddIthVar( p->dd, Vec_IntEntry(p->vObj2Var,Aig_ObjId(pObj)) );
-    Saig_ManForEachLo( p->pAig, pObj, i )
-    {
-        if ( fUseNsVars )
-            Entry = Vec_IntEntry( p->vObj2Var, Aig_ObjId(Saig_ObjLoToLi(p->pAig, pObj)) );
-        else
-            Entry = Vec_IntEntry( p->vObj2Var, Aig_ObjId(pObj) );
-        pObj->pData = Cudd_bddIthVar( p->dd, Entry );
-    }
-    // transfer them to the global AIG
-    Aig_ManCleanData( p->pAigGlo );
-    Aig_ManConst1( p->pAigGlo )->pData = Cudd_ReadOne( p->dd );
-    Aig_ManForEachCi( p->pAigGlo, pObj, i )
-        pObj->pData = Aig_ManCi(p->pAig, i)->pData;
-    // derive consraints
-    bConstr = Cudd_ReadOne( p->dd );   Cudd_Ref( bConstr );
-    Vec_IntForEachEntry( vHints, Entry, i )
-    {
-        if ( Entry != 0 && Entry != 1 )
-            continue;
-        bFunc = Llb_ManConstructOutBdd( p->pAigGlo, Aig_ManObj(p->pAigGlo, i), p->dd );  Cudd_Ref( bFunc );
-        bFunc = Cudd_NotCond( bFunc, Entry ); // restrict to not constraint
-        // make the product
-        bConstr = Cudd_bddAnd( p->dd, bTemp = bConstr, bFunc );                          Cudd_Ref( bConstr );
-        Cudd_RecursiveDeref( p->dd, bTemp );
-        Cudd_RecursiveDeref( p->dd, bFunc );
-    }
-    Cudd_Deref( bConstr );
-    p->dd->TimeStop = TimeStop;
-    return bConstr;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Perform reachability with hints and returns reached states in ppGlo.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Abc_Cex_t * Llb_ManReachDeriveCex( Llb_Man_t * p )
-{
-    Abc_Cex_t * pCex;
-    Aig_Obj_t * pObj;
-    DdNode * bState = NULL, * bImage, * bOneCube, * bTemp, * bRing;
-    int i, v, RetValue, nPiOffset;
-    char * pValues = ABC_ALLOC( char, Cudd_ReadSize(p->ddR) );
-    assert( Vec_PtrSize(p->vRings) > 0 );
-
-    p->dd->TimeStop  = 0;
-    p->ddR->TimeStop = 0;
-
-/*
-    Saig_ManForEachLo( p->pAig, pObj, i )
-        printf( "%d ", pObj->Id );
-    printf( "\n" );
-    Saig_ManForEachLi( p->pAig, pObj, i )
-        printf( "%d(%d) ", pObj->Id, Aig_ObjFaninId0(pObj) );
-    printf( "\n" );
-*/
-    // allocate room for the counter-example
-    pCex = Abc_CexAlloc( Saig_ManRegNum(p->pAig), Saig_ManPiNum(p->pAig), Vec_PtrSize(p->vRings) );
-    pCex->iFrame = Vec_PtrSize(p->vRings) - 1;
-    pCex->iPo = -1;
-
-    // get the last cube
-    bOneCube = Cudd_bddIntersect( p->ddR, (DdNode *)Vec_PtrEntryLast(p->vRings), p->ddR->bFunc );  Cudd_Ref( bOneCube );
-    RetValue = Cudd_bddPickOneCube( p->ddR, bOneCube, pValues );
-    Cudd_RecursiveDeref( p->ddR, bOneCube );
-    assert( RetValue );
-
-    // write PIs of counter-example
-    nPiOffset = Saig_ManRegNum(p->pAig) + Saig_ManPiNum(p->pAig) * (Vec_PtrSize(p->vRings) - 1);
-    Saig_ManForEachPi( p->pAig, pObj, i )
-        if ( pValues[Saig_ManRegNum(p->pAig)+i] == 1 )
-            Abc_InfoSetBit( pCex->pData, nPiOffset + i );
-
-    // write state in terms of NS variables
-    if ( Vec_PtrSize(p->vRings) > 1 )
-    {
-        bState = Llb_CoreComputeCube( p->dd, p->vGlo2Ns, 1, pValues );   Cudd_Ref( bState );
-    }
-    // perform backward analysis
-    Vec_PtrForEachEntryReverse( DdNode *, p->vRings, bRing, v )
-    { 
-        if ( v == Vec_PtrSize(p->vRings) - 1 )
-            continue;
-//Extra_bddPrintSupport( p->dd, bState );  printf( "\n" );
-//Extra_bddPrintSupport( p->dd, bRing );   printf( "\n" );
-        // compute the next states
-        bImage = Llb_ManComputeImage( p, bState, 1 ); 
-        assert( bImage != NULL );
-        Cudd_Ref( bImage );
-        Cudd_RecursiveDeref( p->dd, bState );
-//Extra_bddPrintSupport( p->dd, bImage );  printf( "\n" );
-
-        // move reached states into ring manager
-        bImage = Extra_TransferPermute( p->dd, p->ddR, bTemp = bImage, Vec_IntArray(p->vCs2Glo) );    Cudd_Ref( bImage );
-        Cudd_RecursiveDeref( p->dd, bTemp );
-//Extra_bddPrintSupport( p->ddR, bImage );  printf( "\n" );
-
-        // intersect with the previous set
-        bOneCube = Cudd_bddIntersect( p->ddR, bImage, bRing );                Cudd_Ref( bOneCube );
-        Cudd_RecursiveDeref( p->ddR, bImage );
-
-        // find any assignment of the BDD
-        RetValue = Cudd_bddPickOneCube( p->ddR, bOneCube, pValues );
-        Cudd_RecursiveDeref( p->ddR, bOneCube );
-        assert( RetValue );
-/*
-        for ( i = 0; i < p->ddR->size; i++ )
-            printf( "%d ", pValues[i] );
-        printf( "\n" );
-*/
-        // write PIs of counter-example
-        nPiOffset -= Saig_ManPiNum(p->pAig);
-        Saig_ManForEachPi( p->pAig, pObj, i )
-            if ( pValues[Saig_ManRegNum(p->pAig)+i] == 1 )
-                Abc_InfoSetBit( pCex->pData, nPiOffset + i );
-
-        // check that we get the init state
-        if ( v == 0 )
-        {
-            Saig_ManForEachLo( p->pAig, pObj, i )
-                assert( pValues[i] == 0 );
-            break;
-        }
-
-        // write state in terms of NS variables
-        bState = Llb_CoreComputeCube( p->dd, p->vGlo2Ns, 1, pValues );   Cudd_Ref( bState );
-    }
-    assert( nPiOffset == Saig_ManRegNum(p->pAig) );
-    // update the output number
-//Abc_CexPrint( pCex );
-    RetValue = Saig_ManFindFailedPoCex( p->pAigGlo, pCex );
-    assert( RetValue >= 0 && RetValue < Saig_ManPoNum(p->pAigGlo) ); // invalid CEX!!!
-    pCex->iPo = RetValue;
-    // cleanup
-    ABC_FREE( pValues );
-    return pCex;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Perform reachability with hints and returns reached states in ppGlo.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_ManReachability( Llb_Man_t * p, Vec_Int_t * vHints, DdManager ** pddGlo )
-{
-    int * pNs2Glo = Vec_IntArray( p->vNs2Glo );
-    int * pCs2Glo = Vec_IntArray( p->vCs2Glo );
-    int * pGlo2Cs = Vec_IntArray( p->vGlo2Cs );
-    DdNode * bCurrent, * bReached, * bNext, * bTemp, * bCube;
-    DdNode * bConstrCs, * bConstrNs;
-    abctime clk2, clk = Abc_Clock();
-    int nIters, nBddSize = 0;
-//    int nThreshold = 10000;
-
-    // compute time to stop
-    p->pPars->TimeTarget = p->pPars->TimeLimit ? p->pPars->TimeLimit * CLOCKS_PER_SEC + Abc_Clock(): 0;
-
-    // define variable limits
-    Llb_ManPrepareVarLimits( p );
-
-    // start the managers
-    assert( p->dd == NULL );
-    assert( p->ddG == NULL );
-    assert( p->ddR == NULL );
-    p->dd  = Cudd_Init( Vec_IntSize(p->vVar2Obj), 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
-    p->ddR = Cudd_Init( Aig_ManCiNum(p->pAig),    0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
-    if ( pddGlo && *pddGlo )
-        p->ddG = *pddGlo, *pddGlo = NULL; 
-    else
-        p->ddG = Cudd_Init( Aig_ManRegNum(p->pAig),   0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
-
-    if ( p->pPars->fReorder )
-    {
-        Cudd_AutodynEnable( p->dd,  CUDD_REORDER_SYMM_SIFT );
-        Cudd_AutodynEnable( p->ddG, CUDD_REORDER_SYMM_SIFT );
-        Cudd_AutodynEnable( p->ddR, CUDD_REORDER_SYMM_SIFT );
-    }
-    else
-    {
-        Cudd_AutodynDisable( p->dd );
-        Cudd_AutodynDisable( p->ddG );
-        Cudd_AutodynDisable( p->ddR );
-    }
-
-    // set the stop time parameter
-    p->dd->TimeStop  = p->pPars->TimeTarget;
-    p->ddG->TimeStop = p->pPars->TimeTarget;
-    p->ddR->TimeStop = p->pPars->TimeTarget;
-
-    // create bad state in the ring manager
-    p->ddR->bFunc  = Llb_BddComputeBad( p->pAigGlo, p->ddR, p->pPars->TimeTarget );          
-    if ( p->ddR->bFunc == NULL )
-    {
-        if ( !p->pPars->fSilent )
-            printf( "Reached timeout (%d seconds) during constructing the bad states.\n", p->pPars->TimeLimit );
-        p->pPars->iFrame = -1;
-        return -1;
-    }
-    Cudd_Ref( p->ddR->bFunc );
-
-    // derive constraints
-    bConstrCs = Llb_ManCreateConstraints( p, vHints, 0 );   Cudd_Ref( bConstrCs );
-    bConstrNs = Llb_ManCreateConstraints( p, vHints, 1 );   Cudd_Ref( bConstrNs );
-//Extra_bddPrint( p->dd, bConstrCs ); printf( "\n" );
-//Extra_bddPrint( p->dd, bConstrNs ); printf( "\n" );
-
-    // perform reachability analysis
-    // compute the starting set of states
-    if ( p->ddG->bFunc )
-    {
-        bReached = p->ddG->bFunc; p->ddG->bFunc = NULL;
-        bCurrent = Extra_TransferPermute( p->ddG, p->dd, bReached, pGlo2Cs );    Cudd_Ref( bCurrent );
-    }
-    else
-    {
-        bReached = Llb_ManComputeInitState( p, p->ddG );                         Cudd_Ref( bReached );
-        bCurrent = Llb_ManComputeInitState( p, p->dd  );                         Cudd_Ref( bCurrent );
-    }
-//Extra_bddPrintSupport( p->ddG, bReached ); printf( "\n" );
-//Extra_bddPrintSupport( p->dd,  bCurrent ); printf( "\n" );
-
-//Extra_bddPrintSupport( p->dd, bCurrent ); printf( "\n" );
-    for ( nIters = 0; nIters < p->pPars->nIterMax; nIters++ )
-    { 
-        clk2 = Abc_Clock();
-        // check the runtime limit
-        if ( p->pPars->TimeLimit && Abc_Clock() > p->pPars->TimeTarget )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached timeout during image computation (%d seconds).\n",  p->pPars->TimeLimit );
-            p->pPars->iFrame = nIters - 1;
-            Cudd_RecursiveDeref( p->dd,  bCurrent );  bCurrent = NULL;
-            Cudd_RecursiveDeref( p->dd,  bConstrCs ); bConstrCs = NULL;
-            Cudd_RecursiveDeref( p->dd,  bConstrNs ); bConstrNs = NULL;
-            Cudd_RecursiveDeref( p->ddG, bReached );  bReached = NULL;
-            return -1;
-        }
-
-        // save the onion ring
-        bTemp = Extra_TransferPermute( p->dd, p->ddR, bCurrent, pCs2Glo );
-        if ( bTemp == NULL )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached timeout (%d seconds) during ring transfer.\n",  p->pPars->TimeLimit );
-            p->pPars->iFrame = nIters - 1;
-            Cudd_RecursiveDeref( p->dd,  bCurrent );  bCurrent = NULL;
-            Cudd_RecursiveDeref( p->dd,  bConstrCs ); bConstrCs = NULL;
-            Cudd_RecursiveDeref( p->dd,  bConstrNs ); bConstrNs = NULL;
-            Cudd_RecursiveDeref( p->ddG, bReached );  bReached = NULL;
-            return -1;
-        }
-        Cudd_Ref( bTemp );
-        Vec_PtrPush( p->vRings, bTemp );
-
-        // check it for bad states
-        if ( !p->pPars->fSkipOutCheck && !Cudd_bddLeq( p->ddR, bTemp, Cudd_Not(p->ddR->bFunc) ) ) 
-        {
-            assert( p->pAigGlo->pSeqModel == NULL );
-            if ( !p->pPars->fBackward )
-                p->pAigGlo->pSeqModel = Llb_ManReachDeriveCex( p ); 
-            if ( !p->pPars->fSilent )
-            {
-                if ( !p->pPars->fBackward )
-                    Abc_Print( 1, "Output %d of miter \"%s\" was asserted in frame %d.  ", p->pAigGlo->pSeqModel->iPo, p->pAigGlo->pName, p->pAigGlo->pName, nIters );
-                else
-                    Abc_Print( 1, "Output ??? of miter \"%s\" was asserted in frame %d (counter-example is not produced).  ", p->pAigGlo->pName, nIters );
-                Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
-            }
-            p->pPars->iFrame = nIters - 1;
-            Cudd_RecursiveDeref( p->dd,  bCurrent );  bCurrent = NULL;
-            Cudd_RecursiveDeref( p->dd,  bConstrCs ); bConstrCs = NULL;
-            Cudd_RecursiveDeref( p->dd,  bConstrNs ); bConstrNs = NULL;
-            Cudd_RecursiveDeref( p->ddG, bReached );  bReached = NULL;
-            return 0; 
-        }
-
-        // restrict reachable states using constraints
-        if ( vHints )
-        {
-            bCurrent = Cudd_bddAnd( p->dd, bTemp = bCurrent, bConstrCs );                                Cudd_Ref( bCurrent );
-            Cudd_RecursiveDeref( p->dd, bTemp );
-        }
-
-        // quantify variables appearing only in the init state
-        bCube    = Llb_ManConstructQuantCubeIntern( p, (Llb_Grp_t *)Vec_PtrEntry(p->vGroups,0), 0, 0 );  Cudd_Ref( bCube );
-        bCurrent = Cudd_bddExistAbstract( p->dd, bTemp = bCurrent, bCube );                              Cudd_Ref( bCurrent );
-        Cudd_RecursiveDeref( p->dd, bTemp );
-        Cudd_RecursiveDeref( p->dd, bCube );
-
-        // compute the next states
-        bNext = Llb_ManComputeImage( p, bCurrent, 0 );
-        if ( bNext == NULL )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached timeout (%d seconds) during image computation.\n",  p->pPars->TimeLimit );
-            p->pPars->iFrame = nIters - 1;
-            Cudd_RecursiveDeref( p->dd,  bCurrent );   bCurrent = NULL;
-            Cudd_RecursiveDeref( p->dd,  bConstrCs );  bConstrCs = NULL;
-            Cudd_RecursiveDeref( p->dd,  bConstrNs );  bConstrNs = NULL;
-            Cudd_RecursiveDeref( p->ddG, bReached );   bReached = NULL;
-            return -1;
-        }
-        Cudd_Ref( bNext );
-        Cudd_RecursiveDeref( p->dd, bCurrent ); bCurrent = NULL;
-
-        // restrict reachable states using constraints
-        if ( vHints )
-        {
-            bNext = Cudd_bddAnd( p->dd, bTemp = bNext, bConstrNs );                Cudd_Ref( bNext );
-            Cudd_RecursiveDeref( p->dd, bTemp );
-        }
-//Extra_bddPrintSupport( p->dd, bNext ); printf( "\n" );
-
-        // remap these states into the current state vars
-//        bNext = Extra_TransferPermute( p->dd, p->ddG, bTemp = bNext, pNs2Glo );    Cudd_Ref( bNext );
-//        Cudd_RecursiveDeref( p->dd, bTemp );
-//        bNext = Extra_TransferPermuteTime( p->dd, p->ddG, bTemp = bNext, pNs2Glo, p->pPars->TimeTarget );    
-        bNext = Extra_TransferPermute( p->dd, p->ddG, bTemp = bNext, pNs2Glo );    
-        if ( bNext == NULL )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached timeout (%d seconds) during image computation in transfer 1.\n",  p->pPars->TimeLimit );
-            p->pPars->iFrame = nIters - 1;
-            Cudd_RecursiveDeref( p->dd,  bTemp );  
-            Cudd_RecursiveDeref( p->dd,  bConstrCs );  bConstrCs = NULL;
-            Cudd_RecursiveDeref( p->dd,  bConstrNs );  bConstrNs = NULL;
-            Cudd_RecursiveDeref( p->ddG, bReached );   bReached = NULL;
-            return -1;
-        }
-        Cudd_Ref( bNext );
-        Cudd_RecursiveDeref( p->dd, bTemp );  
-
-
-        // check if there are any new states
-        if ( Cudd_bddLeq( p->ddG, bNext, bReached ) ) // implication = no new states
-        {
-            Cudd_RecursiveDeref( p->ddG,  bNext );     bNext = NULL;
-            break;
-        }
-
-        // check the BDD size
-        nBddSize = Cudd_DagSize(bNext);
-        if ( nBddSize > p->pPars->nBddMax )
-        {
-            Cudd_RecursiveDeref( p->ddG,  bNext );     bNext = NULL;
-            break;
-        }
-
-        // get the new states
-        bCurrent = Cudd_bddAnd( p->ddG, bNext, Cudd_Not(bReached) );
-        if ( bCurrent == NULL )
-        {
-            Cudd_RecursiveDeref( p->ddG,  bNext );        bNext = NULL;
-            Cudd_RecursiveDeref( p->ddG,  bReached );     bReached = NULL;
-            break;
-        }
-        Cudd_Ref( bCurrent );
-        // minimize the new states with the reached states
-//        bCurrent = Cudd_bddConstrain( p->ddG, bTemp = bCurrent, Cudd_Not(bReached) ); Cudd_Ref( bCurrent );
-//        bCurrent = Cudd_bddRestrict( p->ddG, bTemp = bCurrent, Cudd_Not(bReached) );  Cudd_Ref( bCurrent );
-//        Cudd_RecursiveDeref( p->ddG, bTemp );
-//printf( "Initial BDD =%7d. Constrained BDD =%7d.\n", Cudd_DagSize(bTemp), Cudd_DagSize(bCurrent) );
-
-        // remap these states into the current state vars
-//        bCurrent = Extra_TransferPermute( p->ddG, p->dd, bTemp = bCurrent, pGlo2Cs );   Cudd_Ref( bCurrent );
-//        Cudd_RecursiveDeref( p->ddG, bTemp );
-//        bCurrent = Extra_TransferPermuteTime( p->ddG, p->dd, bTemp = bCurrent, pGlo2Cs, p->pPars->TimeTarget );    
-        bCurrent = Extra_TransferPermute( p->ddG, p->dd, bTemp = bCurrent, pGlo2Cs );    
-        if ( bCurrent == NULL )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached timeout (%d seconds) during image computation in transfer 2.\n",  p->pPars->TimeLimit );
-            p->pPars->iFrame = nIters - 1;
-            Cudd_RecursiveDeref( p->ddG, bTemp );  
-            Cudd_RecursiveDeref( p->dd,  bConstrCs );  bConstrCs = NULL;
-            Cudd_RecursiveDeref( p->dd,  bConstrNs );  bConstrNs = NULL;
-            Cudd_RecursiveDeref( p->ddG, bReached );   bReached = NULL;
-            return -1;
-        }
-        Cudd_Ref( bCurrent );
-        Cudd_RecursiveDeref( p->ddG, bTemp ); 
-        
-
-        // add to the reached states
-        bReached = Cudd_bddOr( p->ddG, bTemp = bReached, bNext );                       
-        if ( bReached == NULL )
-        {
-            Cudd_RecursiveDeref( p->ddG,  bTemp );     bTemp = NULL;
-            Cudd_RecursiveDeref( p->ddG,  bNext );     bNext = NULL;
-            break;
-        }
-        Cudd_Ref( bReached );
-        Cudd_RecursiveDeref( p->ddG, bTemp );
-        Cudd_RecursiveDeref( p->ddG, bNext );
-        bNext = NULL;
-
-        if ( p->pPars->fVerbose )
-        {
-            fprintf( stdout, "F =%5d : ",    nIters );
-            fprintf( stdout, "Im =%6d  ",    nBddSize );
-            fprintf( stdout, "(%4d %3d)   ", Cudd_ReadReorderings(p->dd),  Cudd_ReadGarbageCollections(p->dd) );
-            fprintf( stdout, "Rea =%6d  ",   Cudd_DagSize(bReached) );
-            fprintf( stdout, "(%4d%4d)   ",  Cudd_ReadReorderings(p->ddG), Cudd_ReadGarbageCollections(p->ddG) );
-            Abc_PrintTime( 1, "Time", Abc_Clock() - clk2 );
-        }
-/*
-        if ( p->pPars->fVerbose )
-        {
-            double nMints = Cudd_CountMinterm(p->ddG, bReached, Saig_ManRegNum(p->pAig) );
-//            Extra_bddPrint( p->ddG, bReached );printf( "\n" );
-            fprintf( stdout, "Reachable states = %.0f. (Ratio = %.4f %%)\n", nMints, 100.0*nMints/pow(2.0, Saig_ManRegNum(p->pAig)) );
-            fflush( stdout ); 
-        }
-*/
-    }
-    Cudd_RecursiveDeref( p->dd, bConstrCs ); bConstrCs = NULL;
-    Cudd_RecursiveDeref( p->dd, bConstrNs ); bConstrNs = NULL;
-    if ( bReached == NULL )
-    {
-        p->pPars->iFrame = nIters - 1;
-        return 0; // reachable
-    }
-//    assert( bCurrent == NULL );
-    if ( bCurrent )
-        Cudd_RecursiveDeref( p->dd, bCurrent );
-    // report the stats
-    if ( p->pPars->fVerbose )
-    {
-        double nMints = Cudd_CountMinterm(p->ddG, bReached, Saig_ManRegNum(p->pAig) );
-        if ( nIters >= p->pPars->nIterMax || nBddSize > p->pPars->nBddMax )
-            fprintf( stdout, "Reachability analysis is stopped after %d frames.\n", nIters );
-        else
-            fprintf( stdout, "Reachability analysis completed after %d frames.\n", nIters );
-        fprintf( stdout, "Reachable states = %.0f. (Ratio = %.4f %%)\n", nMints, 100.0*nMints/pow(2.0, Saig_ManRegNum(p->pAig)) );
-        fflush( stdout ); 
-    }
-    if ( nIters >= p->pPars->nIterMax || nBddSize > p->pPars->nBddMax )
-    {
-        if ( !p->pPars->fSilent )
-            printf( "Verified only for states reachable in %d frames.  ", nIters );
-        p->pPars->iFrame = p->pPars->nIterMax;
-        Cudd_RecursiveDeref( p->ddG, bReached );
-        return -1; // undecided
-    }
-    if ( pddGlo ) 
-    {
-        assert( p->ddG->bFunc == NULL );
-        p->ddG->bFunc = bReached; bReached = NULL;
-        assert( *pddGlo == NULL );
-        *pddGlo = p->ddG;  p->ddG = NULL;
-    }
-    else
-        Cudd_RecursiveDeref( p->ddG, bReached );
-    if ( !p->pPars->fSilent )
-        printf( "The miter is proved unreachable after %d iterations.  ", nIters );
-    p->pPars->iFrame = nIters - 1;
-    return 1; // unreachable
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/llb/llb1Sched.c b/src/proof/llb/llb1Sched.c
deleted file mode 100644
index 51de973a..00000000
--- a/src/proof/llb/llb1Sched.c
+++ /dev/null
@@ -1,257 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [llb1Sched.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD based reachability.]
-
-  Synopsis    [Partition scheduling algorithm.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: llb1Sched.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "llbInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Swaps two rows.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_MtrSwapColumns( Llb_Mtr_t * p, int iCol1, int iCol2 )
-{
-    Llb_Grp_t * pGemp;
-    char * pTemp;
-    int iTemp;
-    assert( iCol1 >= 0 && iCol1 < p->nCols );
-    assert( iCol2 >= 0 && iCol2 < p->nCols );
-    if ( iCol1 == iCol2 )
-        return;
-    assert( iCol1 != iCol2 );
-    // swap col groups
-    pGemp = p->pColGrps[iCol1];
-    p->pColGrps[iCol1] = p->pColGrps[iCol2];
-    p->pColGrps[iCol2] = pGemp;
-    // swap col vectors
-    pTemp = p->pMatrix[iCol1];
-    p->pMatrix[iCol1] = p->pMatrix[iCol2];
-    p->pMatrix[iCol2] = pTemp;
-    // swap col sums
-    iTemp = p->pColSums[iCol1];
-    p->pColSums[iCol1] = p->pColSums[iCol2];
-    p->pColSums[iCol2] = iTemp;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Find columns which brings as few vars as possible.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_MtrFindBestColumn( Llb_Mtr_t * p, int iGrpStart )
-{
-    int Cost, Cost2, CostBest = ABC_INFINITY, Cost2Best = ABC_INFINITY;
-    int WeightCur, WeightBest = -ABC_INFINITY, iGrp = -1, iGrpBest = -1;
-    int k, c, iVar, Counter;
-    // find partition that reduces partial product as much as possible
-    for ( iVar = 0; iVar < p->nRows - p->nFfs; iVar++ )
-    { 
-        if ( p->pRowSums[iVar] < 2 )
-            continue;
-        // look at present variables that can be quantified
-        if ( !(p->pProdVars[iVar] == 1 && p->pProdNums[iVar] == 1) )
-            continue;
-        // check that it appears in one partition only
-        Counter = 0;
-        for ( c = iGrpStart; c < p->nCols-1; c++ )
-            if ( p->pMatrix[c][iVar] == 1 )
-            {
-                iGrp = c;
-                Counter++;
-            }
-        assert( Counter == 1 );
-        if ( Counter != 1 )
-            Abc_Print( -1, "Llb_MtrFindBestColumn() Internal error!\n" );
-        // find weight of this column
-        WeightCur = 0;
-        for ( k = 0; k < p->nRows; k++ )
-        {
-            // increase weight if variable k will be quantified from partial product
-            if ( p->pProdVars[k] == 1 && p->pMatrix[iGrp][k] == 1 && p->pProdNums[k] == 1 ) 
-                WeightCur += 2;
-            // decrease weight if variable k will be added to partial product
-            if ( p->pProdVars[k] == 0 && p->pMatrix[iGrp][k] == 1 )
-                WeightCur--;
-        }
-        if ( WeightCur > 0 && WeightBest < WeightCur )
-        {
-            WeightBest = WeightCur;
-            iGrpBest   = iGrp;
-        }
-    }
-    if ( iGrpBest >= 0 )
-        return iGrpBest;
-    // could not find the group with any vars to quantify
-    // select the group that contains as few extra variables as possible
-    // if there is a tie, select variables that appear in less groups than others
-    for ( iGrp = iGrpStart; iGrp < p->nCols-1; iGrp++ )
-    {
-        Cost = Cost2 = 0;
-        for ( k = 0; k < p->nRows; k++ )
-            if ( p->pProdVars[k] == 0 && p->pMatrix[iGrp][k] == 1 )
-            {
-                Cost++;
-                Cost2 += p->pProdNums[k];
-            }
-        if ( CostBest >  Cost || 
-            (CostBest == Cost && Cost2 > Cost2Best) )
-        {
-            CostBest  = Cost;
-            Cost2Best = Cost2;
-            iGrpBest  = iGrp;
-        }
-    }
-    return iGrpBest;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns the number of variables that will be saved.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_MtrUseSelectedColumn( Llb_Mtr_t * p, int iCol )
-{
-    int iVar;
-    assert( iCol >= 1 && iCol < p->nCols - 1 );
-    for ( iVar = 0; iVar < p->nRows; iVar++ )
-    {
-        if ( p->pMatrix[iCol][iVar] == 0 )
-            continue;
-        if ( p->pProdVars[iVar] == 1 && p->pProdNums[iVar] == 1 )
-        {
-            p->pProdVars[iVar] = 0;
-            p->pProdNums[iVar] = 0;
-            continue;
-        }
-        if ( p->pProdVars[iVar] == 0 )
-        {
-            p->pProdVars[iVar] = 1;
-            p->pProdNums[iVar] = p->pRowSums[iVar];
-        }
-        p->pProdNums[iVar]--;
-        assert( p->pProdNums[iVar] >= 0 );
-        if ( p->pProdNums[iVar] < 0 )
-            Abc_Print( -1, "Llb_MtrUseSelectedColumn() Internal error!\n" );
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Verify columns.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_MtrVerifyColumns( Llb_Mtr_t * p, int iGrpStart )
-{
-    int iVar, iGrp, Counter;
-    for ( iVar = 0; iVar < p->nRows; iVar++ )
-    {
-        if ( p->pProdVars[iVar] == 0 )
-            continue;
-        Counter = 0;
-        for ( iGrp = iGrpStart; iGrp < p->nCols; iGrp++ )
-            if ( p->pMatrix[iGrp][iVar] == 1 )
-                Counter++;
-        assert( Counter == p->pProdNums[iVar] );
-        if ( Counter != p->pProdNums[iVar] )
-            Abc_Print( -1, "Llb_MtrVerifyColumns(): Internal error.\n" );
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Matrix reduce.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_MtrSchedule( Llb_Mtr_t * p )
-{
-    int iGrp, iGrpBest, i;
-    // start partial product
-    for ( i = 0; i < p->nRows; i++ )
-    {
-        if ( i >= p->nPis && i < p->nPis + p->nFfs )
-        {
-            p->pProdVars[i] = 1;
-            p->pProdNums[i] = p->pRowSums[i] - 1;
-        }
-        else 
-        {
-            p->pProdVars[i] = 0;
-            p->pProdNums[i] = p->pRowSums[i];
-        }
-    }
-    // order the partitions
-    Llb_MtrVerifyMatrix( p );
-    for ( iGrp = 1; iGrp < p->nCols-1; iGrp++ )
-    {
-        Llb_MtrVerifyColumns( p, iGrp );
-        iGrpBest = Llb_MtrFindBestColumn( p, iGrp );
-        Llb_MtrUseSelectedColumn( p, iGrpBest );
-        Llb_MtrSwapColumns( p, iGrp, iGrpBest );
-    }
-    Llb_MtrVerifyMatrix( p );
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/llb/llb2Bad.c b/src/proof/llb/llb2Bad.c
deleted file mode 100644
index ac04b563..00000000
--- a/src/proof/llb/llb2Bad.c
+++ /dev/null
@@ -1,138 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [llb2Bad.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD based reachability.]
-
-  Synopsis    [Computing bad states.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: llb2Bad.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "llbInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
- 
-/**Function*************************************************************
-
-  Synopsis    [Computes bad in working manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb_BddComputeBad( Aig_Man_t * pInit, DdManager * dd, abctime TimeOut )
-{
-    Vec_Ptr_t * vNodes;
-    DdNode * bBdd0, * bBdd1, * bTemp, * bResult;
-    Aig_Obj_t * pObj;
-    int i, k;
-    assert( Cudd_ReadSize(dd) == Aig_ManCiNum(pInit) );
-    // initialize elementary variables
-    Aig_ManConst1(pInit)->pData = Cudd_ReadOne( dd );
-    Saig_ManForEachLo( pInit, pObj, i )
-        pObj->pData = Cudd_bddIthVar( dd, i );
-    Saig_ManForEachPi( pInit, pObj, i )
-        pObj->pData = Cudd_bddIthVar( dd, Aig_ManRegNum(pInit) + i );
-    // compute internal nodes
-    vNodes = Aig_ManDfsNodes( pInit, (Aig_Obj_t **)Vec_PtrArray(pInit->vCos), Saig_ManPoNum(pInit) );
-    Vec_PtrForEachEntry( Aig_Obj_t *, vNodes, pObj, i )
-    {
-        if ( !Aig_ObjIsNode(pObj) )
-            continue;
-        bBdd0 = Cudd_NotCond( (DdNode *)Aig_ObjFanin0(pObj)->pData, Aig_ObjFaninC0(pObj) );
-        bBdd1 = Cudd_NotCond( (DdNode *)Aig_ObjFanin1(pObj)->pData, Aig_ObjFaninC1(pObj) );
-//        pObj->pData = Extra_bddAndTime( dd, bBdd0, bBdd1, TimeOut );
-        pObj->pData = Cudd_bddAnd( dd, bBdd0, bBdd1 );
-        if ( pObj->pData == NULL )
-        {
-            Vec_PtrForEachEntryStop( Aig_Obj_t *, vNodes, pObj, k, i )
-                if ( pObj->pData )
-                    Cudd_RecursiveDeref( dd, (DdNode *)pObj->pData );
-            Vec_PtrFree( vNodes );
-            return NULL;
-        }
-        Cudd_Ref( (DdNode *)pObj->pData );
-    }
-    // quantify PIs of each PO
-    bResult = Cudd_ReadLogicZero( dd );  Cudd_Ref( bResult );
-    Saig_ManForEachPo( pInit, pObj, i )
-    {
-        bBdd0   = Cudd_NotCond( Aig_ObjFanin0(pObj)->pData, Aig_ObjFaninC0(pObj) );
-        bResult = Cudd_bddOr( dd, bTemp = bResult, bBdd0 );     Cudd_Ref( bResult );
-        Cudd_RecursiveDeref( dd, bTemp );
-    }
-    // deref
-    Vec_PtrForEachEntry( Aig_Obj_t *, vNodes, pObj, i )
-    {
-        if ( !Aig_ObjIsNode(pObj) )
-            continue;
-        Cudd_RecursiveDeref( dd, (DdNode *)pObj->pData );
-    }
-    Vec_PtrFree( vNodes );
-    Cudd_Deref( bResult );
-    return bResult;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb_BddQuantifyPis( Aig_Man_t * pInit, DdManager * dd, DdNode * bFunc )
-{
-    DdNode * bVar, * bCube, * bTemp;
-    Aig_Obj_t * pObj;
-    int i;
-    abctime TimeStop;
-    assert( Cudd_ReadSize(dd) == Aig_ManCiNum(pInit) );
-    TimeStop = dd->TimeStop; dd->TimeStop = 0;
-    // create PI cube
-    bCube = Cudd_ReadOne( dd );  Cudd_Ref( bCube );
-    Saig_ManForEachPi( pInit, pObj, i )    {
-        bVar  = Cudd_bddIthVar( dd, Aig_ManRegNum(pInit) + i );
-        bCube = Cudd_bddAnd( dd, bTemp = bCube, bVar );  Cudd_Ref( bCube );
-        Cudd_RecursiveDeref( dd, bTemp );
-    }
-    // quantify PI cube
-    bFunc = Cudd_bddExistAbstract( dd, bFunc, bCube );  Cudd_Ref( bFunc );
-    Cudd_RecursiveDeref( dd, bCube );
-    Cudd_Deref( bFunc );
-    dd->TimeStop = TimeStop;
-    return bFunc;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/llb/llb2Core.c b/src/proof/llb/llb2Core.c
deleted file mode 100644
index 3d62b322..00000000
--- a/src/proof/llb/llb2Core.c
+++ /dev/null
@@ -1,777 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [llb2Core.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD based reachability.]
-
-  Synopsis    [Core procedure.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: llb2Core.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "llbInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-typedef struct Llb_Img_t_ Llb_Img_t;
-struct Llb_Img_t_
-{
-    Aig_Man_t *     pInit;          // AIG manager
-    Aig_Man_t *     pAig;           // AIG manager
-    Gia_ParLlb_t *  pPars;          // parameters
-
-    DdManager *     dd;             // BDD manager
-    DdManager *     ddG;            // BDD manager
-    DdManager *     ddR;            // BDD manager
-    Vec_Ptr_t *     vDdMans;        // BDD managers for each partition
-    Vec_Ptr_t *     vRings;         // onion rings in ddR
-
-    Vec_Int_t *     vDriRefs;       // driver references
-    Vec_Int_t *     vVarsCs;        // cur state variables
-    Vec_Int_t *     vVarsNs;        // next state variables
-
-    Vec_Int_t *     vCs2Glo;        // cur state variables into global variables
-    Vec_Int_t *     vNs2Glo;        // next state variables into global variables
-    Vec_Int_t *     vGlo2Cs;        // global variables into cur state variables
-    Vec_Int_t *     vGlo2Ns;        // global variables into next state variables
-};
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Computes cube composed of given variables with given values.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb_CoreComputeCube( DdManager * dd, Vec_Int_t * vVars, int fUseVarIndex, char * pValues )
-{
-    DdNode * bRes, * bVar, * bTemp;
-    int i, iVar, Index;
-    abctime TimeStop;
-    TimeStop = dd->TimeStop; dd->TimeStop = 0;
-    bRes = Cudd_ReadOne( dd );   Cudd_Ref( bRes );
-    Vec_IntForEachEntry( vVars, Index, i )
-    {
-        iVar  = fUseVarIndex ? Index : i;
-        bVar  = Cudd_NotCond( Cudd_bddIthVar(dd, iVar), (int)(pValues == NULL || pValues[i] != 1) );
-        bRes  = Cudd_bddAnd( dd, bTemp = bRes, bVar );  Cudd_Ref( bRes );
-        Cudd_RecursiveDeref( dd, bTemp );
-    }
-    Cudd_Deref( bRes );
-    dd->TimeStop = TimeStop;
-    return bRes;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Derives counter-example by backward reachability.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Abc_Cex_t * Llb_CoreDeriveCex( Llb_Img_t * p )
-{
-    Abc_Cex_t * pCex;
-    Aig_Obj_t * pObj;
-    Vec_Ptr_t * vSupps, * vQuant0, * vQuant1;
-    DdNode * bState = NULL, * bImage, * bOneCube, * bTemp, * bRing;
-    int i, v, RetValue, nPiOffset;
-    char * pValues = ABC_ALLOC( char, Cudd_ReadSize(p->ddR) );
-    assert( Vec_PtrSize(p->vRings) > 0 );
-
-    p->dd->TimeStop  = 0;
-    p->ddR->TimeStop = 0;
-
-    // get supports and quantified variables
-    Vec_PtrReverseOrder( p->vDdMans );
-    vSupps = Llb_ImgSupports( p->pAig, p->vDdMans, p->vVarsNs, p->vVarsCs, 1, 0 );
-    Llb_ImgSchedule( vSupps, &vQuant0, &vQuant1, 0 );
-    Vec_VecFree( (Vec_Vec_t *)vSupps );
-    Llb_ImgQuantifyReset( p->vDdMans );
-//    Llb_ImgQuantifyFirst( p->pAig, p->vDdMans, vQuant0 );
-
-    // allocate room for the counter-example
-    pCex = Abc_CexAlloc( Saig_ManRegNum(p->pAig), Saig_ManPiNum(p->pAig), Vec_PtrSize(p->vRings) );
-    pCex->iFrame = Vec_PtrSize(p->vRings) - 1;
-    pCex->iPo = -1;
-
-    // get the last cube
-    bOneCube = Cudd_bddIntersect( p->ddR, (DdNode *)Vec_PtrEntryLast(p->vRings), p->ddR->bFunc );  Cudd_Ref( bOneCube );
-    RetValue = Cudd_bddPickOneCube( p->ddR, bOneCube, pValues );
-    Cudd_RecursiveDeref( p->ddR, bOneCube );
-    assert( RetValue );
-
-    // write PIs of counter-example
-    nPiOffset = Saig_ManRegNum(p->pAig) + Saig_ManPiNum(p->pAig) * (Vec_PtrSize(p->vRings) - 1);
-    Saig_ManForEachPi( p->pAig, pObj, i )
-        if ( pValues[Saig_ManRegNum(p->pAig)+i] == 1 )
-            Abc_InfoSetBit( pCex->pData, nPiOffset + i );
-
-    // write state in terms of NS variables
-    if ( Vec_PtrSize(p->vRings) > 1 )
-    {
-        bState = Llb_CoreComputeCube( p->dd, p->vVarsNs, 1, pValues );   Cudd_Ref( bState );
-    }
-    // perform backward analysis
-    Vec_PtrForEachEntryReverse( DdNode *, p->vRings, bRing, v )
-    { 
-        if ( v == Vec_PtrSize(p->vRings) - 1 )
-            continue;
-        // compute the next states
-        bImage = Llb_ImgComputeImage( p->pAig, p->vDdMans, p->dd, bState, 
-            vQuant0, vQuant1, p->vDriRefs, p->pPars->TimeTarget, 1, 0, 0 );
-        assert( bImage != NULL );
-        Cudd_Ref( bImage );
-        Cudd_RecursiveDeref( p->dd, bState );
-//Extra_bddPrintSupport( p->dd, bImage ); printf( "\n" );
-
-        // move reached states into ring manager
-        bImage = Extra_TransferPermute( p->dd, p->ddR, bTemp = bImage, Vec_IntArray(p->vCs2Glo) );    Cudd_Ref( bImage );
-        Cudd_RecursiveDeref( p->dd, bTemp );
-
-        // intersect with the previous set
-        bOneCube = Cudd_bddIntersect( p->ddR, bImage, bRing );                Cudd_Ref( bOneCube );
-        Cudd_RecursiveDeref( p->ddR, bImage );
-
-        // find any assignment of the BDD
-        RetValue = Cudd_bddPickOneCube( p->ddR, bOneCube, pValues );
-        Cudd_RecursiveDeref( p->ddR, bOneCube );
-        assert( RetValue );
-
-        // write PIs of counter-example
-        nPiOffset -= Saig_ManPiNum(p->pAig);
-        Saig_ManForEachPi( p->pAig, pObj, i )
-            if ( pValues[Saig_ManRegNum(p->pAig)+i] == 1 )
-                Abc_InfoSetBit( pCex->pData, nPiOffset + i );
-
-        // check that we get the init state
-        if ( v == 0 )
-        {
-            Saig_ManForEachLo( p->pAig, pObj, i )
-                assert( pValues[i] == 0 );
-            break;
-        }
-
-        // write state in terms of NS variables
-        bState = Llb_CoreComputeCube( p->dd, p->vVarsNs, 1, pValues );   Cudd_Ref( bState );
-    }
-    assert( nPiOffset == Saig_ManRegNum(p->pAig) );
-    // update the output number
-    RetValue = Saig_ManFindFailedPoCex( p->pInit, pCex );
-    assert( RetValue >= 0 && RetValue < Saig_ManPoNum(p->pInit) ); // invalid CEX!!!
-    pCex->iPo = RetValue;
-    // cleanup
-    ABC_FREE( pValues );
-    Vec_VecFree( (Vec_Vec_t *)vQuant0 );
-    Vec_VecFree( (Vec_Vec_t *)vQuant1 );
-    return pCex;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_CoreReachability_int( Llb_Img_t * p, Vec_Ptr_t * vQuant0, Vec_Ptr_t * vQuant1 )
-{
-    int * pLoc2Glo  = p->pPars->fBackward? Vec_IntArray( p->vCs2Glo ) : Vec_IntArray( p->vNs2Glo );
-    int * pLoc2GloR = p->pPars->fBackward? Vec_IntArray( p->vNs2Glo ) : Vec_IntArray( p->vCs2Glo );
-    int * pGlo2Loc  = p->pPars->fBackward? Vec_IntArray( p->vGlo2Ns ) : Vec_IntArray( p->vGlo2Cs );
-    DdNode * bCurrent, * bReached, * bNext, * bTemp;
-    abctime clk2, clk = Abc_Clock();
-    int nIters, nBddSize;//, iOutFail = -1;
-/*
-    // compute time to stop
-    if ( p->pPars->TimeLimit )
-        p->pPars->TimeTarget = Abc_Clock() + p->pPars->TimeLimit * CLOCKS_PER_SEC;
-    else
-        p->pPars->TimeTarget = 0;
-*/
-
-    if ( Abc_Clock() > p->pPars->TimeTarget )
-    {
-        if ( !p->pPars->fSilent )
-            printf( "Reached timeout (%d seconds) before image computation.\n", p->pPars->TimeLimit );
-        p->pPars->iFrame = -1;
-        return -1;
-    }
-
-    // set the stop time parameter
-    p->dd->TimeStop  = p->pPars->TimeTarget;
-    p->ddG->TimeStop = p->pPars->TimeTarget;
-    p->ddR->TimeStop = p->pPars->TimeTarget;
-
-    // compute initial states
-    if ( p->pPars->fBackward )
-    {
-        // create init state in the global manager
-        bTemp = Llb_BddComputeBad( p->pInit, p->ddR, p->pPars->TimeTarget );   
-        if ( bTemp == NULL )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached timeout (%d seconds) while computing bad states.\n", p->pPars->TimeLimit );
-            p->pPars->iFrame = -1;
-            return -1;
-        }
-        Cudd_Ref( bTemp );
-        // create bad state in the ring manager
-        p->ddR->bFunc = Llb_CoreComputeCube( p->ddR, p->vVarsCs, 0, NULL );      Cudd_Ref( p->ddR->bFunc );
-        bCurrent = Llb_BddQuantifyPis( p->pInit, p->ddR, bTemp );                Cudd_Ref( bCurrent );
-        Cudd_RecursiveDeref( p->ddR, bTemp );
-        bReached = Cudd_bddTransfer( p->ddR, p->ddG, bCurrent );                 Cudd_Ref( bReached );
-        Cudd_RecursiveDeref( p->ddR, bCurrent );
-        // move init state to the working manager
-        bCurrent = Extra_TransferPermute( p->ddG, p->dd, bReached, pGlo2Loc );   
-        if ( bCurrent == NULL )
-        {
-            Cudd_RecursiveDeref( p->ddG, bReached );
-            if ( !p->pPars->fSilent )
-                printf( "Reached timeout (%d seconds) during transfer 0.\n", p->pPars->TimeLimit );
-            p->pPars->iFrame = -1;
-            return -1;
-        }
-        Cudd_Ref( bCurrent );
-    }
-    else
-    {
-        // create bad state in the ring manager
-        p->ddR->bFunc = Llb_BddComputeBad( p->pInit, p->ddR, p->pPars->TimeTarget );  
-        if ( p->ddR->bFunc == NULL )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached timeout (%d seconds) while computing bad states.\n", p->pPars->TimeLimit );
-            p->pPars->iFrame = -1;
-            return -1;
-        }
-        Cudd_Ref( p->ddR->bFunc );
-        // create init state in the working and global manager
-        bCurrent = Llb_CoreComputeCube( p->dd,  p->vVarsCs, 1, NULL );           Cudd_Ref( bCurrent );
-        bReached = Llb_CoreComputeCube( p->ddG, p->vVarsCs, 0, NULL );           Cudd_Ref( bReached );
-//Extra_bddPrint( p->dd, bCurrent );  printf( "\n" );
-//Extra_bddPrint( p->ddG, bReached );  printf( "\n" );
-    }
-
-    // compute onion rings
-    for ( nIters = 0; nIters < p->pPars->nIterMax; nIters++ )
-    { 
-        clk2 = Abc_Clock();
-        // check the runtime limit
-        if ( p->pPars->TimeLimit && Abc_Clock() > p->pPars->TimeTarget )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached timeout (%d seconds) during image computation.\n",  p->pPars->TimeLimit );
-            p->pPars->iFrame = nIters - 1;
-            Cudd_RecursiveDeref( p->dd,  bCurrent );  bCurrent = NULL;
-            Cudd_RecursiveDeref( p->ddG, bReached );  bReached = NULL;
-            return -1;
-        }
-
-        // save the onion ring
-        bTemp = Extra_TransferPermute( p->dd, p->ddR, bCurrent, pLoc2GloR );  
-        if ( bTemp == NULL )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached timeout (%d seconds) during image computation.\n",  p->pPars->TimeLimit );
-            p->pPars->iFrame = nIters - 1;
-            Cudd_RecursiveDeref( p->dd,  bCurrent );  bCurrent = NULL;
-            Cudd_RecursiveDeref( p->ddG, bReached );  bReached = NULL;
-            return -1;
-        }
-        Cudd_Ref( bTemp );
-        Vec_PtrPush( p->vRings, bTemp );
-
-        // check it for bad states
-        if ( !p->pPars->fSkipOutCheck && !Cudd_bddLeq( p->ddR, bTemp, Cudd_Not(p->ddR->bFunc) ) ) 
-        {
-            assert( p->pInit->pSeqModel == NULL );
-            if ( !p->pPars->fBackward )
-                p->pInit->pSeqModel = Llb_CoreDeriveCex( p ); 
-            Cudd_RecursiveDeref( p->dd,  bCurrent );  bCurrent = NULL;
-            Cudd_RecursiveDeref( p->ddG, bReached );  bReached = NULL;
-            if ( !p->pPars->fSilent )
-            {
-                if ( !p->pPars->fBackward )
-                    Abc_Print( 1, "Output %d of miter \"%s\" was asserted in frame %d.  ", p->pInit->pSeqModel->iPo, p->pInit->pName, nIters );
-                else
-                    Abc_Print( 1, "Output ??? was asserted in frame %d (counter-example is not produced).  ", nIters );
-                Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
-            }
-            p->pPars->iFrame = nIters - 1;
-            return 0;
-        }
-
-        // compute the next states
-        bNext = Llb_ImgComputeImage( p->pAig, p->vDdMans, p->dd, bCurrent, 
-            vQuant0, vQuant1, p->vDriRefs, p->pPars->TimeTarget, 
-            p->pPars->fBackward, p->pPars->fReorder, p->pPars->fVeryVerbose );
-        if ( bNext == NULL )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached timeout (%d seconds) during image computation.\n",  p->pPars->TimeLimit );
-            p->pPars->iFrame = nIters - 1;
-            Cudd_RecursiveDeref( p->dd,  bCurrent );   bCurrent = NULL;
-            Cudd_RecursiveDeref( p->ddG, bReached );   bReached = NULL;
-            return -1;
-        }
-        Cudd_Ref( bNext );
-        Cudd_RecursiveDeref( p->dd, bCurrent );        bCurrent = NULL;
-//Extra_bddPrintSupport( p->dd, bNext ); printf( "\n" );
-
-        // remap these states into the global manager
-//        bNext = Extra_TransferPermute( p->dd, p->ddG, bTemp = bNext, pLoc2Glo );    Cudd_Ref( bNext );
-//        Cudd_RecursiveDeref( p->dd, bTemp );
-
-//        bNext = Extra_TransferPermuteTime( p->dd, p->ddG, bTemp = bNext, pLoc2Glo, p->pPars->TimeTarget );    
-        bNext = Extra_TransferPermute( p->dd, p->ddG, bTemp = bNext, pLoc2Glo );    
-        if ( bNext == NULL )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached timeout (%d seconds) during image computation in transfer 1.\n",  p->pPars->TimeLimit );
-            p->pPars->iFrame = nIters - 1;
-            Cudd_RecursiveDeref( p->dd,  bTemp );  
-            Cudd_RecursiveDeref( p->ddG, bReached );   bReached = NULL;
-            return -1;
-        }
-        Cudd_Ref( bNext );
-        Cudd_RecursiveDeref( p->dd, bTemp );  
-
-        nBddSize = Cudd_DagSize(bNext);
-        // check if there are any new states
-        if ( Cudd_bddLeq( p->ddG, bNext, bReached ) ) // implication = no new states
-        {
-            Cudd_RecursiveDeref( p->ddG,  bNext );     bNext = NULL;
-            break;
-        }
-
-        // get the new states
-        bCurrent = Cudd_bddAnd( p->ddG, bNext, Cudd_Not(bReached) );                    
-        if ( bCurrent == NULL )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached timeout (%d seconds) during image computation in transfer 2.\n",  p->pPars->TimeLimit );
-            p->pPars->iFrame = nIters - 1;
-            Cudd_RecursiveDeref( p->ddG, bNext );  
-            Cudd_RecursiveDeref( p->ddG, bReached );   bReached = NULL;
-            return -1;
-        }
-        Cudd_Ref( bCurrent );
-
-        // remap these states into the current state vars
-//        bCurrent = Extra_TransferPermute( p->ddG, p->dd, bTemp = bCurrent, pGlo2Loc );   Cudd_Ref( bCurrent );
-//        Cudd_RecursiveDeref( p->ddG, bTemp );
-
-//        bCurrent = Extra_TransferPermuteTime( p->ddG, p->dd, bTemp = bCurrent, pGlo2Loc, p->pPars->TimeTarget );    
-        bCurrent = Extra_TransferPermute( p->ddG, p->dd, bTemp = bCurrent, pGlo2Loc );    
-        if ( bCurrent == NULL )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached timeout (%d seconds) during image computation in transfer 2.\n",  p->pPars->TimeLimit );
-            p->pPars->iFrame = nIters - 1;
-            Cudd_RecursiveDeref( p->ddG, bTemp );  
-            Cudd_RecursiveDeref( p->ddG, bReached );   bReached = NULL;
-            return -1;
-        }
-        Cudd_Ref( bCurrent );
-        Cudd_RecursiveDeref( p->ddG, bTemp );
-
-        // add to the reached states
-        bReached = Cudd_bddOr( p->ddG, bTemp = bReached, bNext );                       Cudd_Ref( bReached );
-        Cudd_RecursiveDeref( p->ddG, bTemp );
-        Cudd_RecursiveDeref( p->ddG, bNext );
-        bNext = NULL;
-
-        if ( p->pPars->fVeryVerbose )
-        {
-            double nMints = Cudd_CountMinterm(p->ddG, bReached, Saig_ManRegNum(p->pAig) );
-//            Extra_bddPrint( p->ddG, bReached );printf( "\n" );
-            fprintf( stdout, "        Reachable states = %.0f. (Ratio = %.4f %%)\n", nMints, 100.0*nMints/pow(2.0, Saig_ManRegNum(p->pAig)) );
-            fflush( stdout ); 
-        }
-        if ( p->pPars->fVerbose )
-        {
-            fprintf( stdout, "F =%3d : ",    nIters );
-            fprintf( stdout, "Image =%6d  ", nBddSize );
-            fprintf( stdout, "(%4d%4d)  ", 
-                Cudd_ReadReorderings(p->dd),  Cudd_ReadGarbageCollections(p->dd) );
-            fprintf( stdout, "Reach =%6d  ", Cudd_DagSize(bReached) );
-            fprintf( stdout, "(%4d%4d)  ", 
-                Cudd_ReadReorderings(p->ddG), Cudd_ReadGarbageCollections(p->ddG) );
-            Abc_PrintTime( 1, "Time", Abc_Clock() - clk2 );
-        }
-
-        // check timeframe limit
-        if ( nIters == p->pPars->nIterMax - 1 )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached limit on the number of timeframes (%d).\n",  p->pPars->nIterMax );
-            p->pPars->iFrame = nIters;
-            Cudd_RecursiveDeref( p->dd,  bCurrent );  bCurrent = NULL;
-            Cudd_RecursiveDeref( p->ddG, bReached );  bReached = NULL;
-            return -1;
-        }
-    }
-    if ( bReached == NULL )
-    {
-        p->pPars->iFrame = nIters - 1;
-        return 0; // reachable
-    }
-    if ( bCurrent )
-        Cudd_RecursiveDeref( p->dd, bCurrent );
-    // report the stats
-    if ( p->pPars->fVerbose )
-    {
-        double nMints = Cudd_CountMinterm(p->ddG, bReached, Saig_ManRegNum(p->pAig) );
-        if ( nIters >= p->pPars->nIterMax )
-            fprintf( stdout, "Reachability analysis is stopped after %d frames.\n", nIters );
-        else
-            fprintf( stdout, "Reachability analysis completed after %d frames.\n", nIters );
-        fprintf( stdout, "Reachable states = %.0f. (Ratio = %.4f %%)\n", nMints, 100.0*nMints/pow(2.0, Saig_ManRegNum(p->pAig)) );
-        fflush( stdout ); 
-    }
-    if ( p->pPars->fDumpReached )
-    {
-        Llb_ManDumpReached( p->ddG, bReached, p->pAig->pName, "reached.blif" );
-        printf( "Reached states with %d BDD nodes are dumpted into file \"reached.blif\".\n", Cudd_DagSize(bReached) );
-    }
-    Cudd_RecursiveDeref( p->ddG, bReached );
-    if ( nIters >= p->pPars->nIterMax )
-    {
-        if ( !p->pPars->fSilent )
-        {
-            printf( "Verified only for states reachable in %d frames.  ", nIters );
-            Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
-        }
-        p->pPars->iFrame = p->pPars->nIterMax;
-        return -1; // undecided
-    }
-    if ( !p->pPars->fSilent )
-    {
-        printf( "The miter is proved unreachable after %d iterations.  ", nIters );
-        Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
-    }
-    p->pPars->iFrame = nIters - 1;
-    return 1; // unreachable
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_CoreReachability( Llb_Img_t * p )
-{
-    Vec_Ptr_t * vSupps, * vQuant0, * vQuant1;
-    int RetValue;
-    // get supports and quantified variables
-    if ( p->pPars->fBackward )
-    {
-        Vec_PtrReverseOrder( p->vDdMans );
-        vSupps = Llb_ImgSupports( p->pAig, p->vDdMans, p->vVarsNs, p->vVarsCs, 0, p->pPars->fVeryVerbose );
-    }
-    else
-        vSupps = Llb_ImgSupports( p->pAig, p->vDdMans, p->vVarsCs, p->vVarsNs, 0, p->pPars->fVeryVerbose );
-    Llb_ImgSchedule( vSupps, &vQuant0, &vQuant1, p->pPars->fVeryVerbose );
-    Vec_VecFree( (Vec_Vec_t *)vSupps );
-    // remove variables
-    Llb_ImgQuantifyFirst( p->pAig, p->vDdMans, vQuant0, p->pPars->fVeryVerbose );
-    // perform reachability
-    RetValue = Llb_CoreReachability_int( p, vQuant0, vQuant1 );
-    Vec_VecFree( (Vec_Vec_t *)vQuant0 );
-    Vec_VecFree( (Vec_Vec_t *)vQuant1 );
-    return RetValue;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Ptr_t * Llb_CoreConstructAll( Aig_Man_t * p, Vec_Ptr_t * vResult, Vec_Int_t * vVarsNs, abctime TimeTarget )
-{
-    DdManager * dd;
-    Vec_Ptr_t * vDdMans;
-    Vec_Ptr_t * vLower, * vUpper = NULL;
-    int i;
-    vDdMans = Vec_PtrStart( Vec_PtrSize(vResult) );
-    Vec_PtrForEachEntryReverse( Vec_Ptr_t *, vResult, vLower, i )
-    {
-        if ( i < Vec_PtrSize(vResult) - 1 )
-            dd = Llb_ImgPartition( p, vLower, vUpper, TimeTarget );
-        else
-            dd = Llb_DriverLastPartition( p, vVarsNs, TimeTarget );
-        if ( dd == NULL )
-        {
-            Vec_PtrForEachEntry( DdManager *, vDdMans, dd, i )
-            {
-                if ( dd == NULL )
-                    continue;
-                if ( dd->bFunc )
-                    Cudd_RecursiveDeref( dd, dd->bFunc );
-                Extra_StopManager( dd );
-            }
-            Vec_PtrFree( vDdMans );
-            return NULL;
-        }
-        Vec_PtrWriteEntry( vDdMans, i, dd );
-        vUpper = vLower;
-    }
-    return vDdMans;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_CoreSetVarMaps( Llb_Img_t * p )
-{
-    Aig_Obj_t * pObj;
-    int i, iVarCs, iVarNs;
-    assert( p->vVarsCs != NULL );
-    assert( p->vVarsNs != NULL );
-    assert( p->vCs2Glo == NULL );
-    assert( p->vNs2Glo == NULL );
-    assert( p->vGlo2Cs == NULL );
-    assert( p->vGlo2Ns == NULL );
-    p->vCs2Glo = Vec_IntStartFull( Aig_ManObjNumMax(p->pAig) );
-    p->vNs2Glo = Vec_IntStartFull( Aig_ManObjNumMax(p->pAig) );
-    p->vGlo2Cs = Vec_IntStartFull( Aig_ManRegNum(p->pAig) );
-    p->vGlo2Ns = Vec_IntStartFull( Aig_ManRegNum(p->pAig) );
-    for ( i = 0; i < Aig_ManRegNum(p->pAig); i++ )
-    {
-        iVarCs = Vec_IntEntry( p->vVarsCs, i );
-        iVarNs = Vec_IntEntry( p->vVarsNs, i );
-        assert( iVarCs >= 0 && iVarCs < Aig_ManObjNumMax(p->pAig) );
-        assert( iVarNs >= 0 && iVarNs < Aig_ManObjNumMax(p->pAig) );
-        Vec_IntWriteEntry( p->vCs2Glo, iVarCs, i );
-        Vec_IntWriteEntry( p->vNs2Glo, iVarNs, i );
-        Vec_IntWriteEntry( p->vGlo2Cs, i, iVarCs );
-        Vec_IntWriteEntry( p->vGlo2Ns, i, iVarNs );
-    }
-    // add mapping of the PIs
-    Saig_ManForEachPi( p->pAig, pObj, i )
-        Vec_IntWriteEntry( p->vCs2Glo, Aig_ObjId(pObj), Aig_ManRegNum(p->pAig)+i );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Llb_Img_t * Llb_CoreStart( Aig_Man_t * pInit, Aig_Man_t * pAig, Gia_ParLlb_t *  pPars )
-{
-    Llb_Img_t * p;
-    p = ABC_CALLOC( Llb_Img_t, 1 );
-    p->pInit = pInit;
-    p->pAig  = pAig;
-    p->pPars = pPars;
-    p->dd    = Cudd_Init( Aig_ManObjNumMax(pAig), 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
-    p->ddG   = Cudd_Init( Aig_ManRegNum(pAig),    0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
-    p->ddR   = Cudd_Init( Aig_ManCiNum(pAig),     0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
-    Cudd_AutodynEnable( p->dd,  CUDD_REORDER_SYMM_SIFT );
-    Cudd_AutodynEnable( p->ddG, CUDD_REORDER_SYMM_SIFT );
-    Cudd_AutodynEnable( p->ddR, CUDD_REORDER_SYMM_SIFT );
-    p->vRings = Vec_PtrAlloc( 100 );
-    p->vDriRefs = Llb_DriverCountRefs( pAig );
-    p->vVarsCs  = Llb_DriverCollectCs( pAig );
-    p->vVarsNs  = Llb_DriverCollectNs( pAig, p->vDriRefs );
-    Llb_CoreSetVarMaps( p );
-    return p;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_CoreStop( Llb_Img_t * p )
-{
-    DdManager * dd;
-    DdNode * bTemp;
-    int i;
-    if ( p->vDdMans )
-    Vec_PtrForEachEntry( DdManager *, p->vDdMans, dd, i )
-    {
-        if ( dd->bFunc )
-            Cudd_RecursiveDeref( dd, dd->bFunc );
-        if ( dd->bFunc2 )
-            Cudd_RecursiveDeref( dd, dd->bFunc2 );
-        Extra_StopManager( dd );
-    }
-    Vec_PtrFreeP( &p->vDdMans );
-    if ( p->ddR->bFunc )
-        Cudd_RecursiveDeref( p->ddR, p->ddR->bFunc );
-    Vec_PtrForEachEntry( DdNode *, p->vRings, bTemp, i )
-        Cudd_RecursiveDeref( p->ddR, bTemp );
-    Vec_PtrFree( p->vRings );
-    Extra_StopManager( p->dd );
-    Extra_StopManager( p->ddG );
-    Extra_StopManager( p->ddR );
-    Vec_IntFreeP( &p->vDriRefs );
-    Vec_IntFreeP( &p->vVarsCs );
-    Vec_IntFreeP( &p->vVarsNs );
-    Vec_IntFreeP( &p->vCs2Glo );
-    Vec_IntFreeP( &p->vNs2Glo );
-    Vec_IntFreeP( &p->vGlo2Cs );
-    Vec_IntFreeP( &p->vGlo2Ns );
-    ABC_FREE( p );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_CoreExperiment( Aig_Man_t * pInit, Aig_Man_t * pAig, Gia_ParLlb_t * pPars, Vec_Ptr_t * vResult, abctime TimeTarget )
-{
-    int RetValue;
-    Llb_Img_t * p;
-//    printf( "\n" );
-//    pPars->fVerbose = 1;
-    p = Llb_CoreStart( pInit, pAig, pPars );
-    p->vDdMans = Llb_CoreConstructAll( pAig, vResult, p->vVarsNs, TimeTarget );
-    if ( p->vDdMans == NULL )
-    {
-        if ( !pPars->fSilent )
-            printf( "Reached timeout (%d seconds) while deriving the partitions.\n", pPars->TimeLimit );
-        Llb_CoreStop( p );
-        return -1;
-    }
-    RetValue = Llb_CoreReachability( p );
-    Llb_CoreStop( p );
-    return RetValue;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Finds balanced cut.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_ManReachMinCut( Aig_Man_t * pAig, Gia_ParLlb_t * pPars )
-{
-    extern Vec_Ptr_t * Llb_ManComputeCuts( Aig_Man_t * p, int Num, int fVerbose, int fVeryVerbose );
-    Vec_Ptr_t * vResult;
-    Aig_Man_t * p;
-    int RetValue = -1;
-    abctime clk = Abc_Clock();
-
-    // compute time to stop
-    pPars->TimeTarget = pPars->TimeLimit ? pPars->TimeLimit * CLOCKS_PER_SEC + Abc_Clock(): 0;
-
-    p = Aig_ManDupFlopsOnly( pAig );
-//Aig_ManShow( p, 0, NULL );
-    if ( pPars->fVerbose )
-    Aig_ManPrintStats( pAig );
-    if ( pPars->fVerbose )
-    Aig_ManPrintStats( p );
-    Aig_ManFanoutStart( p );
-
-    vResult = Llb_ManComputeCuts( p, pPars->nPartValue, pPars->fVerbose, pPars->fVeryVerbose );
-
-    if ( pPars->TimeLimit && Abc_Clock() > pPars->TimeTarget )
-    {
-        if ( !pPars->fSilent )
-            printf( "Reached timeout (%d seconds) after partitioning.\n", pPars->TimeLimit );
-
-        Vec_VecFree( (Vec_Vec_t *)vResult );
-        Aig_ManFanoutStop( p );
-        Aig_ManCleanMarkAB( p );
-        Aig_ManStop( p );
-        return RetValue;
-    }
-
-    if ( !pPars->fSkipReach )
-        RetValue = Llb_CoreExperiment( pAig, p, pPars, vResult, pPars->TimeTarget );
-
-    Vec_VecFree( (Vec_Vec_t *)vResult );
-    Aig_ManFanoutStop( p );
-    Aig_ManCleanMarkAB( p );
-    Aig_ManStop( p );
-
-    if ( RetValue == -1 )
-        Abc_PrintTime( 1, "Total runtime of the min-cut-based reachability engine", Abc_Clock() - clk );
-    return RetValue;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/llb/llb2Driver.c b/src/proof/llb/llb2Driver.c
deleted file mode 100644
index 1471f377..00000000
--- a/src/proof/llb/llb2Driver.c
+++ /dev/null
@@ -1,222 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [llb2Driver.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD based reachability.]
-
-  Synopsis    [Procedures working with flop drivers.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: llb2Driver.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "llbInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-// driver issue:arises when creating
-// - driver ref-counter array
-// - Ns2Glo maps
-// - final partition
-// - change-phase cube
-
-// LI variable is used when
-// - driver drives more than one LI
-// - driver is a PI
-// - driver is a constant
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Returns the array of times each flop driver is referenced.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Int_t * Llb_DriverCountRefs( Aig_Man_t * p )
-{
-    Vec_Int_t * vCounts;
-    Aig_Obj_t * pObj;
-    int i;
-    vCounts = Vec_IntStart( Aig_ManObjNumMax(p) );
-    Saig_ManForEachLi( p, pObj, i )
-        Vec_IntAddToEntry( vCounts, Aig_ObjFaninId0(pObj), 1 );
-    return vCounts;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns array of NS variables.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Int_t * Llb_DriverCollectNs( Aig_Man_t * pAig, Vec_Int_t * vDriRefs )
-{
-    Vec_Int_t * vVars;
-    Aig_Obj_t * pObj, * pDri;
-    int i;
-    vVars = Vec_IntAlloc( Aig_ManRegNum(pAig) );
-    Saig_ManForEachLi( pAig, pObj, i )
-    {
-        pDri = Aig_ObjFanin0(pObj);
-        if ( Vec_IntEntry( vDriRefs, Aig_ObjId(pDri) ) != 1 || Saig_ObjIsPi(pAig, pDri) || Aig_ObjIsConst1(pDri) )
-            Vec_IntPush( vVars, Aig_ObjId(pObj) );
-        else
-            Vec_IntPush( vVars, Aig_ObjId(pDri) );
-    }
-    return vVars;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns array of CS variables.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Int_t * Llb_DriverCollectCs( Aig_Man_t * pAig )
-{
-    Vec_Int_t * vVars;
-    Aig_Obj_t * pObj;
-    int i;
-    vVars = Vec_IntAlloc( Aig_ManRegNum(pAig) );
-    Saig_ManForEachLo( pAig, pObj, i )
-        Vec_IntPush( vVars, Aig_ObjId(pObj) );
-    return vVars;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Create cube for phase swapping.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb_DriverPhaseCube( Aig_Man_t * pAig, Vec_Int_t * vDriRefs, DdManager * dd )
-{
-    DdNode * bCube, * bVar, * bTemp;
-    Aig_Obj_t * pObj;
-    int i;
-    abctime TimeStop;
-    TimeStop = dd->TimeStop; dd->TimeStop = 0;
-    bCube = Cudd_ReadOne( dd );  Cudd_Ref( bCube );
-    Saig_ManForEachLi( pAig, pObj, i )
-    {
-        assert( Vec_IntEntry( vDriRefs, Aig_ObjFaninId0(pObj) ) >= 1 );
-        if ( Vec_IntEntry( vDriRefs, Aig_ObjFaninId0(pObj) ) != 1 )
-            continue;
-        if ( !Aig_ObjFaninC0(pObj) )
-            continue;
-        bVar  = Cudd_bddIthVar( dd, Aig_ObjFaninId0(pObj) );
-        bCube = Cudd_bddAnd( dd, bTemp = bCube, bVar );  Cudd_Ref( bCube );
-        Cudd_RecursiveDeref( dd, bTemp );
-    }
-    Cudd_Deref( bCube );
-    dd->TimeStop = TimeStop;
-    return bCube;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Compute the last partition.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdManager * Llb_DriverLastPartition( Aig_Man_t * p, Vec_Int_t * vVarsNs, abctime TimeTarget )
-{
-//    int fVerbose = 1;
-    DdManager * dd;
-    DdNode * bVar1, * bVar2, * bProd, * bRes, * bTemp;
-    Aig_Obj_t * pObj;
-    int i;
-    dd = Cudd_Init( Aig_ManObjNumMax(p), 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
-    Cudd_AutodynEnable( dd, CUDD_REORDER_SYMM_SIFT );
-    dd->TimeStop = TimeTarget;
-    bRes = Cudd_ReadOne(dd);                                   Cudd_Ref( bRes );
-
-    // mark the duplicated flop inputs
-    Aig_ManForEachObjVec( vVarsNs, p, pObj, i )
-    {
-        if ( !Saig_ObjIsLi(p, pObj) )
-            continue;
-        bVar1 = Cudd_bddIthVar( dd, Aig_ObjId(pObj) );
-        bVar2 = Cudd_bddIthVar( dd, Aig_ObjFaninId0(pObj) );
-        if ( Aig_ObjIsConst1(Aig_ObjFanin0(pObj)) )
-            bVar2 = Cudd_ReadOne(dd);
-        bVar2 = Cudd_NotCond( bVar2, Aig_ObjFaninC0(pObj) );
-        bProd = Cudd_bddXnor( dd, bVar1, bVar2 );              Cudd_Ref( bProd );
-//        bRes  = Cudd_bddAnd( dd, bTemp = bRes, bProd );        Cudd_Ref( bRes );
-//        bRes  = Extra_bddAndTime( dd, bTemp = bRes, bProd, TimeTarget );  
-        bRes  = Cudd_bddAnd( dd, bTemp = bRes, bProd );  
-        if ( bRes == NULL )
-        {
-            Cudd_RecursiveDeref( dd, bTemp );
-            Cudd_RecursiveDeref( dd, bProd );
-            return NULL;
-        }        
-        Cudd_Ref( bRes );
-        Cudd_RecursiveDeref( dd, bTemp );
-        Cudd_RecursiveDeref( dd, bProd );
-    }
-
-/*
-    Saig_ManForEachLi( p, pObj, i )
-        printf( "%d ", Aig_ObjId(pObj) );
-    printf( "\n" );
-    Saig_ManForEachLi( p, pObj, i )
-        printf( "%c%d ", Aig_ObjFaninC0(pObj)? '-':'+', Aig_ObjFaninId0(pObj) );
-    printf( "\n" );
-*/
-    Cudd_AutodynDisable( dd );
-//    Cudd_RecursiveDeref( dd, bRes );
-//    Extra_StopManager( dd );
-    dd->bFunc = bRes;
-    dd->TimeStop = 0;
-    return dd;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/llb/llb2Dump.c b/src/proof/llb/llb2Dump.c
deleted file mode 100644
index 74f07922..00000000
--- a/src/proof/llb/llb2Dump.c
+++ /dev/null
@@ -1,104 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [llb2Dump.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD based reachability.]
-
-  Synopsis    [Dumps the BDD of reached states into a file.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: llb2Dump.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "llbInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Returns a dummy name.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-char * Llb_ManGetDummyName( char * pPrefix, int Num, int nDigits )
-{
-    static char Buffer[2000];
-    sprintf( Buffer, "%s%0*d", pPrefix, nDigits, Num );
-    return Buffer;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Writes reached state BDD into a BLIF file.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManDumpReached( DdManager * ddG, DdNode * bReached, char * pModel, char * pFileName )
-{
-    FILE * pFile;
-    Vec_Ptr_t * vNamesIn, * vNamesOut;
-    char * pName;
-    int i, nDigits;
-    // reorder the BDD
-    Cudd_ReduceHeap( ddG, CUDD_REORDER_SYMM_SIFT, 1 );
-
-    // create input names
-    nDigits = Abc_Base10Log( Cudd_ReadSize(ddG) );
-    vNamesIn = Vec_PtrAlloc( Cudd_ReadSize(ddG) );
-    for ( i = 0; i < Cudd_ReadSize(ddG); i++ )
-    {
-        pName = Llb_ManGetDummyName( "ff", i, nDigits );
-        Vec_PtrPush( vNamesIn, Extra_UtilStrsav(pName) );
-    }
-    // create output names
-    vNamesOut = Vec_PtrAlloc( 1 );
-    Vec_PtrPush( vNamesOut, Extra_UtilStrsav("Reached") );
-
-    // write the file
-    pFile = fopen( pFileName, "wb" );
-    Cudd_DumpBlif( ddG, 1, &bReached, (char **)Vec_PtrArray(vNamesIn), (char **)Vec_PtrArray(vNamesOut), pModel, pFile, 0 );
-    fclose( pFile );
-
-    // cleanup
-    Vec_PtrForEachEntry( char *, vNamesIn, pName, i )
-        ABC_FREE( pName );
-    Vec_PtrForEachEntry( char *, vNamesOut, pName, i )
-        ABC_FREE( pName );
-    Vec_PtrFree( vNamesIn );
-    Vec_PtrFree( vNamesOut );
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/llb/llb2Flow.c b/src/proof/llb/llb2Flow.c
deleted file mode 100644
index 64db32b3..00000000
--- a/src/proof/llb/llb2Flow.c
+++ /dev/null
@@ -1,1376 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [llb2Flow.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD based reachability.]
-
-  Synopsis    [Flow computation.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: llb2Flow.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "llbInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-static inline int         Llb_ObjSetPath( Aig_Obj_t * pObj, Aig_Obj_t * pNext ) { pObj->pData = (void *)pNext; return 1;  }
-static inline Aig_Obj_t * Llb_ObjGetPath( Aig_Obj_t * pObj )                    { return (Aig_Obj_t *)pObj->pData;        }
-static inline Aig_Obj_t * Llb_ObjGetFanoutPath( Aig_Man_t * p, Aig_Obj_t * pObj ) 
-{ 
-    Aig_Obj_t * pFanout;
-    int i, iFanout = -1;
-    assert( Llb_ObjGetPath(pObj) ); 
-    Aig_ObjForEachFanout( p, pObj, pFanout, iFanout, i )
-        if ( Llb_ObjGetPath(pFanout) == pObj )
-            return pFanout;
-    return NULL;
-}
-
-extern Vec_Ptr_t * Llb_ManCutSupp( Aig_Man_t * p, Vec_Ptr_t * vLower, Vec_Ptr_t * vUpper );
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-
-/**Function*************************************************************
-
-  Synopsis    [For each cut, returns PIs that can be quantified.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Ptr_t * Llb_ManCutSupps( Aig_Man_t * p, Vec_Ptr_t * vResult )
-{
-    Vec_Ptr_t * vSupps, * vOne, * vLower, * vUpper;
-    int i;
-    vSupps = Vec_PtrAlloc( 100 );
-    Vec_PtrPush( vSupps, Vec_PtrAlloc(0) );
-    vLower = (Vec_Ptr_t *)Vec_PtrEntry( vResult, 0 );
-    Vec_PtrForEachEntryStart( Vec_Ptr_t *, vResult, vUpper, i, 1 )
-    {
-        vOne  = Llb_ManCutSupp( p, vLower, vUpper );
-        Vec_PtrPush( vSupps, vOne );
-        vLower = vUpper;
-    }
-    assert( Vec_PtrSize(vSupps) == Vec_PtrSize(vResult) );
-    return vSupps;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [For each cut, returns PIs that can be quantified.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Ptr_t * Llb_ManCutMap( Aig_Man_t * p, Vec_Ptr_t * vResult, Vec_Ptr_t * vSupps )
-{
-    int fShowMatrix = 1;
-    Vec_Ptr_t * vMaps, * vOne;
-    Vec_Int_t * vMap, * vPrev, * vNext;
-    Aig_Obj_t * pObj;
-    int * piFirst, * piLast;
-    int i, k, CounterPlus, CounterMinus, Counter;
-
-    vMaps = Vec_PtrAlloc( 100 );
-    Vec_PtrForEachEntry( Vec_Ptr_t *, vResult, vOne, i )
-    {
-        vMap = Vec_IntStart( Aig_ManObjNumMax(p) );
-        Vec_PtrForEachEntry( Aig_Obj_t *, vOne, pObj, k )
-        {
-            if ( !Saig_ObjIsPi(p, pObj) )
-                Vec_IntWriteEntry( vMap, pObj->Id, 1 );
-//            else
-//printf( "*" );
-//printf( "%d ", pObj->Id );
-        }
-        Vec_PtrPush( vMaps, vMap );
-//printf( "\n" );
-    }
-    Vec_PtrPush( vMaps, Vec_IntStart( Aig_ManObjNumMax(p) ) );
-    assert( Vec_PtrSize(vMaps) == Vec_PtrSize(vResult)+1 );
-
-    // collect the first and last PIs
-    piFirst = ABC_ALLOC( int, Saig_ManPiNum(p) );
-    piLast  = ABC_ALLOC( int, Saig_ManPiNum(p) );
-    Saig_ManForEachPi( p, pObj, i )
-        piFirst[i] = piLast[i] = -1;
-    Vec_PtrForEachEntry( Vec_Ptr_t *, vSupps, vOne, i )
-    {
-        Vec_PtrForEachEntry( Aig_Obj_t *, vOne, pObj, k )
-        {
-            if ( !Saig_ObjIsPi(p, pObj) )
-                continue;
-            if ( piFirst[Aig_ObjCioId(pObj)] == -1 )
-                 piFirst[Aig_ObjCioId(pObj)] = i;
-            piLast[Aig_ObjCioId(pObj)] = i;
-        }
-    }
-    // PIs feeding into the flops should be extended to the last frame
-    Saig_ManForEachLi( p, pObj, i )
-    {
-        if ( !Saig_ObjIsPi(p, Aig_ObjFanin0(pObj)) )
-            continue;
-        piLast[Aig_ObjCioId(Aig_ObjFanin0(pObj))] = Vec_PtrSize(vMaps)-1;
-    }
-
-    // set the PI map
-    Saig_ManForEachPi( p, pObj, i )
-    {
-        if ( piFirst[i] == -1 )
-            continue;
-        if ( piFirst[i] == piLast[i] )
-        {
-            vMap = (Vec_Int_t *)Vec_PtrEntry( vMaps, piFirst[i] );
-            Vec_IntWriteEntry( vMap, pObj->Id, 2 );
-            continue;
-        }
-
-        // set support for all in between        
-        for ( k = piFirst[i]; k <= piLast[i]; k++ )
-        {
-            vMap = (Vec_Int_t *)Vec_PtrEntry( vMaps, k );
-            Vec_IntWriteEntry( vMap, pObj->Id, 1 );
-        }
-    }
-    ABC_FREE( piFirst );
-    ABC_FREE( piLast );
-
-
-    // find all that will appear here
-    Counter = Aig_ManRegNum(p);
-    printf( "%d ", Counter );
-    Vec_PtrForEachEntryStart( Vec_Int_t *, vMaps, vMap, i, 1 )
-    {
-        vPrev = (Vec_Int_t *)Vec_PtrEntry( vMaps, i-1 );
-        vNext = (i == Vec_PtrSize(vMaps)-1)? NULL: (Vec_Int_t *)Vec_PtrEntry( vMaps, i+1 );
-
-        CounterPlus = CounterMinus = 0;
-        Aig_ManForEachObj( p, pObj, k )
-        {
-            if ( Saig_ObjIsPi(p, pObj) )
-            {
-                if ( Vec_IntEntry(vPrev, k) == 0 && Vec_IntEntry(vMap, k) == 1 )
-                    CounterPlus++;
-                if ( Vec_IntEntry(vMap, k) == 1 && (vNext == NULL || Vec_IntEntry(vNext, k) == 0) )
-                    CounterMinus++;
-            }
-            else
-            {
-                if ( Vec_IntEntry(vPrev, k) == 0 && Vec_IntEntry(vMap, k) == 1 )
-                    CounterPlus++;
-                if ( Vec_IntEntry(vPrev, k) == 1 && Vec_IntEntry(vMap, k) == 0 )
-                    CounterMinus++;
-            }
-        }
-        Counter = Counter + CounterPlus - CounterMinus;
-        printf( "%d=%d ", i, Counter );
-    }
-    printf( "\n" );
-
-    if ( !fShowMatrix )
-        return vMaps;
-    Aig_ManForEachObj( p, pObj, i )
-    {
-        if ( !Aig_ObjIsCi(pObj) && !Aig_ObjIsNode(pObj) )
-            continue;
-        Vec_PtrForEachEntry( Vec_Int_t *, vMaps, vMap, k )
-            if ( Vec_IntEntry(vMap, i) )
-                break;
-        if ( k == Vec_PtrSize(vMaps) )
-            continue;
-        printf( "Obj = %4d : ", i );
-        if ( Saig_ObjIsPi(p,pObj) )
-            printf( "pi  " );
-        else if ( Saig_ObjIsLo(p,pObj) )
-            printf( "lo  " );
-        else if ( Aig_ObjIsNode(pObj) )
-            printf( "and " );
-
-        Vec_PtrForEachEntry( Vec_Int_t *, vMaps, vMap, k )
-            printf( "%d", Vec_IntEntry(vMap, i) );
-        printf( "\n" );
-    }
-    return vMaps;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Counts the number of PIs in the cut]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_ManCutPiNum( Aig_Man_t * p, Vec_Ptr_t * vMinCut )
-{
-    Aig_Obj_t * pObj;
-    int i, Counter = 0;
-    Vec_PtrForEachEntry( Aig_Obj_t *, vMinCut, pObj, i )
-        if ( Saig_ObjIsPi(p,pObj) )
-            Counter++;
-    return Counter;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Counts the number of LOs in the cut]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_ManCutLoNum( Aig_Man_t * p, Vec_Ptr_t * vMinCut )
-{
-    Aig_Obj_t * pObj;
-    int i, Counter = 0;
-    Vec_PtrForEachEntry( Aig_Obj_t *, vMinCut, pObj, i )
-        if ( Saig_ObjIsLo(p,pObj) )
-            Counter++;
-    return Counter;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Counts the number of LIs in the cut]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_ManCutLiNum( Aig_Man_t * p, Vec_Ptr_t * vMinCut )
-{
-    Aig_Obj_t * pFanout;
-    Aig_Obj_t * pObj;
-    int i, k, iFanout = -1, Counter = 0;
-    Vec_PtrForEachEntry( Aig_Obj_t *, vMinCut, pObj, i )
-    {
-        if ( Aig_ObjIsCi(pObj) )
-            continue;
-        Aig_ObjForEachFanout( p, pObj, pFanout, iFanout, k )
-        {
-            if ( Saig_ObjIsLi(p, pFanout) )
-            {
-                Counter++;
-                break;
-            }
-        }
-    }
-    return Counter;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Computes volume of the cut.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_ManCutVolume_rec( Aig_Man_t * p, Aig_Obj_t * pObj )
-{
-    if ( Aig_ObjIsTravIdCurrent(p, pObj) )
-        return 0;
-    Aig_ObjSetTravIdCurrent(p, pObj);
-    assert( Aig_ObjIsNode(pObj) );
-    return 1 + Llb_ManCutVolume_rec(p, Aig_ObjFanin0(pObj)) + 
-        Llb_ManCutVolume_rec(p, Aig_ObjFanin1(pObj));
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Computes volume of the cut.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_ManCutVolume( Aig_Man_t * p, Vec_Ptr_t * vLower, Vec_Ptr_t * vUpper )
-{
-    Aig_Obj_t * pObj;
-    int i, Counter = 0;
-    // mark the lower cut with the traversal ID
-    Aig_ManIncrementTravId(p);
-    Vec_PtrForEachEntry( Aig_Obj_t *, vLower, pObj, i )
-        Aig_ObjSetTravIdCurrent( p, pObj );
-    // count the upper cut
-    Vec_PtrForEachEntry( Aig_Obj_t *, vUpper, pObj, i )
-        Counter += Llb_ManCutVolume_rec( p, pObj );
-    return Counter;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Computes volume of the cut.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManCutNodes_rec( Aig_Man_t * p, Aig_Obj_t * pObj, Vec_Ptr_t * vNodes )
-{
-    if ( Aig_ObjIsTravIdCurrent(p, pObj) )
-        return;
-    Aig_ObjSetTravIdCurrent(p, pObj);
-    assert( Aig_ObjIsNode(pObj) );
-    Llb_ManCutNodes_rec(p, Aig_ObjFanin0(pObj), vNodes);
-    Llb_ManCutNodes_rec(p, Aig_ObjFanin1(pObj), vNodes);
-    Vec_PtrPush( vNodes, pObj );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Computes volume of the cut.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Ptr_t * Llb_ManCutNodes( Aig_Man_t * p, Vec_Ptr_t * vLower, Vec_Ptr_t * vUpper )
-{
-    Vec_Ptr_t * vNodes;
-    Aig_Obj_t * pObj;
-    int i;
-    // mark the lower cut with the traversal ID
-    Aig_ManIncrementTravId(p);
-    Vec_PtrForEachEntry( Aig_Obj_t *, vLower, pObj, i )
-        Aig_ObjSetTravIdCurrent( p, pObj );
-    // count the upper cut
-    vNodes = Vec_PtrAlloc( 100 );
-    Vec_PtrForEachEntry( Aig_Obj_t *, vUpper, pObj, i )
-        Llb_ManCutNodes_rec( p, pObj, vNodes );
-    return vNodes;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Computes volume of the cut.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Ptr_t * Llb_ManCutSupp( Aig_Man_t * p, Vec_Ptr_t * vLower, Vec_Ptr_t * vUpper )
-{
-    Vec_Ptr_t * vNodes, * vSupp;
-    Aig_Obj_t * pObj;
-    int i;
-    vNodes = Llb_ManCutNodes( p, vLower, vUpper );
-    // mark support of the nodes
-    Aig_ManIncrementTravId(p);
-    Vec_PtrForEachEntry( Aig_Obj_t *, vNodes, pObj, i )
-    {
-        assert( Aig_ObjIsNode(pObj) );
-        Aig_ObjSetTravIdCurrent( p, Aig_ObjFanin0(pObj) );
-        Aig_ObjSetTravIdCurrent( p, Aig_ObjFanin1(pObj) );
-    }
-    Vec_PtrFree( vNodes );
-    // collect the support nodes
-    vSupp = Vec_PtrAlloc( 100 );
-    Vec_PtrForEachEntry( Aig_Obj_t *, vLower, pObj, i )
-        if ( Aig_ObjIsTravIdCurrent(p, pObj) )
-            Vec_PtrPush( vSupp, pObj );
-    return vSupp;
-
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Computes volume of the cut.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Ptr_t * Llb_ManCutRange( Aig_Man_t * p, Vec_Ptr_t * vLower, Vec_Ptr_t * vUpper )
-{
-    Vec_Ptr_t * vRange;
-    Aig_Obj_t * pObj;
-    int i;
-    // mark the lower cut with the traversal ID
-    Aig_ManIncrementTravId(p);
-    Vec_PtrForEachEntry( Aig_Obj_t *, vLower, pObj, i )
-        Aig_ObjSetTravIdCurrent( p, pObj );
-    // collect the upper ones that are not marked
-    vRange = Vec_PtrAlloc( 100 );
-    Vec_PtrForEachEntry( Aig_Obj_t *, vUpper, pObj, i )
-        if ( !Aig_ObjIsTravIdCurrent(p, pObj) )
-            Vec_PtrPush( vRange, pObj );
-    return vRange;
-}
-
-
-
-
-/**Function*************************************************************
-
-  Synopsis    [Prints the given cluster.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManCutPrint( Aig_Man_t * p, Vec_Ptr_t * vLower, Vec_Ptr_t * vUpper )
-{
-    Vec_Ptr_t * vSupp, * vRange;
-    int Pis, Ffs, And;
-
-    Pis = Llb_ManCutPiNum(p, vLower);
-    Ffs = Llb_ManCutLoNum(p, vLower);
-    And = Vec_PtrSize(vLower) - Pis - Ffs;
-    printf( "Leaf: %3d=%3d+%3d+%3d  ",  Vec_PtrSize(vLower), Pis, Ffs, And );
-
-    Pis = Llb_ManCutPiNum(p, vUpper);
-    Ffs = Llb_ManCutLiNum(p, vUpper);
-    And = Vec_PtrSize(vUpper) - Pis - Ffs;
-    printf( "Root: %3d=%3d+%3d+%3d  ", Vec_PtrSize(vUpper), Pis, Ffs, And );
-
-    vSupp = Llb_ManCutSupp( p, vLower, vUpper );
-    Pis = Llb_ManCutPiNum(p, vSupp);
-    Ffs = Llb_ManCutLoNum(p, vSupp);
-    And = Vec_PtrSize(vSupp) - Pis - Ffs;
-    printf( "Supp: %3d=%3d+%3d+%3d  ", Vec_PtrSize(vSupp), Pis, Ffs, And );
-
-    vRange = Llb_ManCutRange( p, vLower, vUpper );
-    Pis = Llb_ManCutPiNum(p, vRange);
-    Ffs = Llb_ManCutLiNum(p, vRange);
-    And = Vec_PtrSize(vRange) - Pis - Ffs;
-    printf( "Range: %3d=%3d+%3d+%3d  ", Vec_PtrSize(vRange), Pis, Ffs, And );
-
-    printf( "S =%3d. V =%3d.\n", 
-        Vec_PtrSize(vSupp)+Vec_PtrSize(vRange), Llb_ManCutVolume(p, vLower, vUpper) );
-    Vec_PtrFree( vSupp );
-    Vec_PtrFree( vRange );
-/*   
-    {
-        Aig_Obj_t * pObj;
-        int i;
-        printf( "Lower: " );
-        Vec_PtrForEachEntry( Aig_Obj_t *, vLower, pObj, i )
-            printf( " %d", pObj->Id );
-        printf( "     " );
-        printf( "Upper: " );
-        Vec_PtrForEachEntry( Aig_Obj_t *, vUpper, pObj, i )
-            printf( " %d", pObj->Id );
-        printf( "\n" );
-    }
-*/
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Prints the given cluster.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManResultPrint( Aig_Man_t * p, Vec_Ptr_t * vResult )
-{
-    Vec_Ptr_t * vLower, * vUpper = NULL;
-    int i;
-    Vec_PtrForEachEntryReverse( Vec_Ptr_t *, vResult, vLower, i )
-    {
-        if ( i < Vec_PtrSize(vResult) - 1 )
-            Llb_ManCutPrint( p, vLower, vUpper );
-        vUpper = vLower;
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Tries to find an augmenting path originating in this node.]
-
-  Description [This procedure works for directed graphs only!]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_ManFlowBwdPath2_rec( Aig_Man_t * p, Aig_Obj_t * pObj )
-{
-    Aig_Obj_t * pFanout;
-    assert( Aig_ObjIsNode(pObj) || Aig_ObjIsCi(pObj) || Aig_ObjIsConst1(pObj) );
-    // skip visited nodes
-    if ( Aig_ObjIsTravIdCurrent(p, pObj) )
-        return 0;
-    Aig_ObjSetTravIdCurrent(p, pObj);
-    // process node without flow
-    if ( !Llb_ObjGetPath(pObj) )
-    {
-        // start the path if we reached a terminal node
-        if ( pObj->fMarkA )
-            return Llb_ObjSetPath( pObj, (Aig_Obj_t *)1 );
-        // explore the fanins
-//        Abc_ObjForEachFanin( pObj, pFanin, i )
-//            if ( Abc_NtkMaxFlowBwdPath2_rec(pFanin) )
-//                return Abc_ObjSetPath( pObj, pFanin );
-        if ( Aig_ObjIsNode(pObj) )
-        {
-            if ( Llb_ManFlowBwdPath2_rec( p, Aig_ObjFanin0(pObj) ) )
-                return Llb_ObjSetPath( pObj, Aig_ObjFanin0(pObj) );
-            if ( Llb_ManFlowBwdPath2_rec( p, Aig_ObjFanin1(pObj) ) )
-                return Llb_ObjSetPath( pObj, Aig_ObjFanin1(pObj) );
-        }
-        return 0;
-    }
-    // pObj has flow - find the fanout with flow
-    pFanout = Llb_ObjGetFanoutPath( p, pObj );
-    if ( pFanout == NULL )
-        return 0;
-    // go through the fanins of the fanout with flow
-//    Abc_ObjForEachFanin( pFanout, pFanin, i )
-//        if ( Abc_NtkMaxFlowBwdPath2_rec( pFanin ) )
-//            return Abc_ObjSetPath( pFanout, pFanin );
-    assert( Aig_ObjIsNode(pFanout) );
-    if ( Llb_ManFlowBwdPath2_rec( p, Aig_ObjFanin0(pFanout) ) )
-        return Llb_ObjSetPath( pFanout, Aig_ObjFanin0(pFanout) );
-    if ( Llb_ManFlowBwdPath2_rec( p, Aig_ObjFanin1(pFanout) ) )
-        return Llb_ObjSetPath( pFanout, Aig_ObjFanin1(pFanout) );
-    // try the fanout
-    if ( Llb_ManFlowBwdPath2_rec( p, pFanout ) )
-        return Llb_ObjSetPath( pFanout, NULL );
-    return 0;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Cleans markB.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManFlowLabelTfi_rec( Aig_Man_t * p, Aig_Obj_t * pObj )
-{
-    if ( Aig_ObjIsTravIdCurrent(p, pObj) )
-        return;
-    Aig_ObjSetTravIdCurrent(p, pObj);
-    if ( Aig_ObjIsCi(pObj) || Aig_ObjIsConst1(pObj) )
-        return;
-    assert( Aig_ObjIsNode(pObj) );
-    Llb_ManFlowLabelTfi_rec( p, Aig_ObjFanin0(pObj) );
-    Llb_ManFlowLabelTfi_rec( p, Aig_ObjFanin1(pObj) );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManFlowUpdateCut( Aig_Man_t * p, Vec_Ptr_t * vMinCut )
-{
-    Aig_Obj_t * pObj;
-    int i;
-    // label the TFI of the cut nodes
-    Aig_ManIncrementTravId(p);
-    Vec_PtrForEachEntry( Aig_Obj_t *, vMinCut, pObj, i )
-        Llb_ManFlowLabelTfi_rec( p, pObj );
-    // collect labeled fanins of non-labeled nodes
-    Vec_PtrClear( vMinCut );
-    Aig_ManIncrementTravId(p);
-    Aig_ManForEachObj( p, pObj, i )
-    {
-        if ( !Aig_ObjIsCo(pObj) && !Aig_ObjIsNode(pObj) )
-            continue;
-        if ( Aig_ObjIsTravIdCurrent(p, pObj) || Aig_ObjIsTravIdPrevious(p, pObj) )
-            continue;
-        if ( Aig_ObjIsTravIdPrevious(p, Aig_ObjFanin0(pObj)) )
-        {
-            Aig_ObjSetTravIdCurrent(p, Aig_ObjFanin0(pObj));
-            Vec_PtrPush( vMinCut, Aig_ObjFanin0(pObj) );
-        }
-        if ( Aig_ObjIsNode(pObj) && Aig_ObjIsTravIdPrevious(p, Aig_ObjFanin1(pObj)) )
-        {
-            Aig_ObjSetTravIdCurrent(p, Aig_ObjFanin1(pObj));
-            Vec_PtrPush( vMinCut, Aig_ObjFanin1(pObj) );
-        }
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Find minimum-volume minumum cut.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Ptr_t * Llb_ManFlowMinCut( Aig_Man_t * p )
-{
-    Vec_Ptr_t * vMinCut;
-    Aig_Obj_t * pObj;
-    int i;
-    // collect the cut nodes
-    vMinCut = Vec_PtrAlloc( Aig_ManRegNum(p) );
-    Aig_ManForEachObj( p, pObj, i )
-    {
-        // node without flow is not a cut node
-        if ( !Llb_ObjGetPath(pObj) )
-            continue;
-        // unvisited node is below the cut
-        if ( !Aig_ObjIsTravIdCurrent(p, pObj) )
-            continue;
-        // add terminal with flow or node whose path is not visited
-        if ( pObj->fMarkA || !Aig_ObjIsTravIdCurrent( p, Llb_ObjGetPath(pObj) ) )
-            Vec_PtrPush( vMinCut, pObj );
-    }
-    return vMinCut;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Verifies the min-cut is indeed a cut.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_ManFlowVerifyCut_rec( Aig_Man_t * p, Aig_Obj_t * pObj )
-{
-    // skip visited nodes
-    if ( Aig_ObjIsTravIdCurrent(p, pObj) )
-        return 1;
-    Aig_ObjSetTravIdCurrent(p, pObj);
-    // visit the node
-    if ( Aig_ObjIsConst1(pObj) )
-        return 1;
-    if ( Aig_ObjIsCi(pObj) )
-        return 0;
-    // explore the fanins
-    assert( Aig_ObjIsNode(pObj) );
-    if ( !Llb_ManFlowVerifyCut_rec(p, Aig_ObjFanin0(pObj)) )
-        return 0;
-    if ( !Llb_ManFlowVerifyCut_rec(p, Aig_ObjFanin1(pObj)) )
-        return 0;
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Verifies the min-cut is indeed a cut.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_ManFlowVerifyCut( Aig_Man_t * p, Vec_Ptr_t * vMinCut )
-{
-    Aig_Obj_t * pObj;
-    int i;
-    // mark the cut with the current traversal ID
-    Aig_ManIncrementTravId(p);
-    Vec_PtrForEachEntry( Aig_Obj_t *, vMinCut, pObj, i )
-        Aig_ObjSetTravIdCurrent( p, pObj );
-    // search from the latches for a path to the COs/CIs
-    Saig_ManForEachLi( p, pObj, i )
-    {
-        if ( !Llb_ManFlowVerifyCut_rec( p, Aig_ObjFanin0(pObj) ) )
-            return 0;
-    }
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Implementation of max-flow/min-cut computation.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Ptr_t * Llb_ManFlow( Aig_Man_t * p, Vec_Ptr_t * vSources, int * pnFlow )
-{
-    Vec_Ptr_t * vMinCut;
-    Aig_Obj_t * pObj;
-    int Flow, FlowCur, RetValue, i;
-    // find the max-flow
-    Flow = 0;
-    Aig_ManCleanData( p );
-    Aig_ManIncrementTravId(p);
-    Vec_PtrForEachEntry( Aig_Obj_t *, vSources, pObj, i )
-    {
-        assert( !pObj->fMarkA && pObj->fMarkB );
-        if ( !Aig_ObjFanin0(pObj)->fMarkB )
-        {
-            FlowCur  = Llb_ManFlowBwdPath2_rec( p, Aig_ObjFanin0(pObj) );
-            Flow    += FlowCur;
-            if ( FlowCur )
-                Aig_ManIncrementTravId(p);
-        }
-        if ( Aig_ObjIsNode(pObj) && !Aig_ObjFanin1(pObj)->fMarkB )
-        {
-            FlowCur  = Llb_ManFlowBwdPath2_rec( p, Aig_ObjFanin1(pObj) );
-            Flow    += FlowCur;
-            if ( FlowCur )
-                Aig_ManIncrementTravId(p);
-        }
-    }
-    if ( pnFlow )
-        *pnFlow = Flow;
-
-    // mark the nodes reachable from the latches
-    Aig_ManIncrementTravId(p);
-    Vec_PtrForEachEntry( Aig_Obj_t *, vSources, pObj, i )
-    {
-        assert( !pObj->fMarkA && pObj->fMarkB );
-        if ( !Aig_ObjFanin0(pObj)->fMarkB )
-        {
-            RetValue = Llb_ManFlowBwdPath2_rec( p, Aig_ObjFanin0(pObj) );
-            assert( RetValue == 0 );
-        }
-        if ( Aig_ObjIsNode(pObj) && !Aig_ObjFanin1(pObj)->fMarkB )
-        {
-            RetValue = Llb_ManFlowBwdPath2_rec( p, Aig_ObjFanin1(pObj) );
-            assert( RetValue == 0 );
-        }
-    }
-
-    // find the min-cut with the smallest volume
-    vMinCut = Llb_ManFlowMinCut( p );
-    assert( Vec_PtrSize(vMinCut) == Flow );
-    // verify the cut
-    if ( !Llb_ManFlowVerifyCut(p, vMinCut) )
-        printf( "Llb_ManFlow() error! The computed min-cut is not a cut!\n" );
-//    Llb_ManFlowPrintCut( p, vMinCut );
-    return vMinCut;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Implementation of max-flow/min-cut computation.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Ptr_t * Llb_ManFlowCompute( Aig_Man_t * p )
-{
-    Vec_Ptr_t * vMinCut;
-    Aig_Obj_t * pObj;
-    int Flow, FlowCur, RetValue, i;
-    // find the max-flow
-    Flow = 0;
-    Aig_ManCleanData( p );
-    Aig_ManIncrementTravId(p);
-    Aig_ManForEachObj( p, pObj, i )
-    {
-        if ( !pObj->fMarkB )
-            continue;
-        assert( !pObj->fMarkA );
-        if ( !Aig_ObjFanin0(pObj)->fMarkB )
-        {
-//printf( "%d ", Aig_ObjFanin0(pObj)->Id );
-            FlowCur  = Llb_ManFlowBwdPath2_rec( p, Aig_ObjFanin0(pObj) );
-            Flow    += FlowCur;
-            if ( FlowCur )
-                Aig_ManIncrementTravId(p);
-        }
-        if ( Aig_ObjIsNode(pObj) && !Aig_ObjFanin1(pObj)->fMarkB )
-        {
-//printf( "%d ", Aig_ObjFanin1(pObj)->Id );
-            FlowCur  = Llb_ManFlowBwdPath2_rec( p, Aig_ObjFanin1(pObj) );
-            Flow    += FlowCur;
-            if ( FlowCur )
-                Aig_ManIncrementTravId(p);
-        }
-    }
-//printf( "\n" );
-
-    // mark the nodes reachable from the latches
-    Aig_ManIncrementTravId(p);
-    Aig_ManForEachObj( p, pObj, i )
-    {
-        if ( !pObj->fMarkB )
-            continue;
-        assert( !pObj->fMarkA );
-        if ( !Aig_ObjFanin0(pObj)->fMarkB )
-        {
-            RetValue = Llb_ManFlowBwdPath2_rec( p, Aig_ObjFanin0(pObj) );
-            assert( RetValue == 0 );
-        }
-        if ( Aig_ObjIsNode(pObj) && !Aig_ObjFanin1(pObj)->fMarkB )
-        {
-            RetValue = Llb_ManFlowBwdPath2_rec( p, Aig_ObjFanin1(pObj) );
-            assert( RetValue == 0 );
-        }
-    }
-    // find the min-cut with the smallest volume
-    vMinCut = Llb_ManFlowMinCut( p );
-    assert( Vec_PtrSize(vMinCut) == Flow );
-//printf( "%d ", Vec_PtrSize(vMinCut) );
-    Llb_ManFlowUpdateCut( p, vMinCut );
-//printf( "%d   ", Vec_PtrSize(vMinCut) );
-    // verify the cut
-    if ( !Llb_ManFlowVerifyCut(p, vMinCut) )
-        printf( "Llb_ManFlow() error! The computed min-cut is not a cut!\n" );
-//    Llb_ManFlowPrintCut( p, vMinCut );
-    return vMinCut;
-}
-
-
-
-
-/**Function*************************************************************
-
-  Synopsis    [Cleans markB.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManFlowCleanMarkB_rec( Aig_Obj_t * pObj )
-{
-    if ( pObj->fMarkB == 0 )
-        return;
-    pObj->fMarkB = 0;
-    assert( Aig_ObjIsNode(pObj) );
-    Llb_ManFlowCleanMarkB_rec( Aig_ObjFanin0(pObj) );
-    Llb_ManFlowCleanMarkB_rec( Aig_ObjFanin1(pObj) );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Cleans markB.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManFlowSetMarkA_rec( Aig_Obj_t * pObj )
-{
-    if ( pObj->fMarkA )
-        return;
-    pObj->fMarkA = 1;
-    if ( Aig_ObjIsCi(pObj) || Aig_ObjIsConst1(pObj) )
-        return;
-    assert( Aig_ObjIsNode(pObj) );
-    Llb_ManFlowSetMarkA_rec( Aig_ObjFanin0(pObj) );
-    Llb_ManFlowSetMarkA_rec( Aig_ObjFanin1(pObj) );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Prepares flow computation.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManFlowPrepareCut( Aig_Man_t * p, Vec_Ptr_t * vLower, Vec_Ptr_t * vUpper )
-{
-    Aig_Obj_t * pObj;
-    int i;
-    // reset marks
-    Aig_ManForEachObj( p, pObj, i )
-    {
-        pObj->fMarkA = 0;
-        pObj->fMarkB = 1;
-    }
-    // clean PIs and const
-    Aig_ManConst1(p)->fMarkB = 0;
-    Aig_ManForEachCi( p, pObj, i )
-        pObj->fMarkB = 0;
-    // clean upper cut
-//printf( "Upper: ");
-    Vec_PtrForEachEntry( Aig_Obj_t *, vUpper, pObj, i )
-    {
-        Llb_ManFlowCleanMarkB_rec( pObj );
-//printf( "%d ", pObj->Id );
-    }
-//printf( "\n" );
-    // set lower cut
-//printf( "Lower: ");
-    Vec_PtrForEachEntry( Aig_Obj_t *, vLower, pObj, i )
-    {
-//printf( "%d ", pObj->Id );
-        assert( pObj->fMarkB == 0 );
-        Llb_ManFlowSetMarkA_rec( pObj );
-    }
-//printf( "\n" );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Prepares flow computation.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManFlowUnmarkCone( Aig_Man_t * p, Vec_Ptr_t * vCone )
-{
-    Aig_Obj_t * pObj;
-    int i;
-    Vec_PtrForEachEntry( Aig_Obj_t *, vCone, pObj, i )
-    {
-        assert( Aig_ObjIsNode(pObj) );
-        assert( pObj->fMarkB == 1 );
-        pObj->fMarkB = 0;
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManFlowCollectAndMarkCone_rec( Aig_Man_t * p, Aig_Obj_t * pObj, Vec_Ptr_t * vCone )
-{
-    Aig_Obj_t * pFanout;
-    int i, iFanout = -1;
-    if ( Saig_ObjIsLi(p, pObj) )
-        return;
-    if ( pObj->fMarkB )
-        return;
-    if ( pObj->fMarkA == 0 )
-    {
-        assert( Aig_ObjIsNode(pObj) );
-        pObj->fMarkB = 1;
-        if ( Aig_ObjIsNode(pObj) )
-            Vec_PtrPush( vCone, pObj );
-    }
-    Aig_ObjForEachFanout( p, pObj, pFanout, iFanout, i )
-        Llb_ManFlowCollectAndMarkCone_rec( p, pFanout, vCone );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Collects the cone.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManFlowCollectAndMarkCone( Aig_Man_t * p, Vec_Ptr_t * vStarts, Vec_Ptr_t * vCone )
-{
-    Aig_Obj_t * pObj;
-    int i;
-    Vec_PtrClear( vCone );
-    Vec_PtrForEachEntry( Aig_Obj_t *, vStarts, pObj, i )
-    {
-        assert( pObj->fMarkA && !pObj->fMarkB );
-        Llb_ManFlowCollectAndMarkCone_rec( p, pObj, vCone );
-    }
-}
-
-
-
-
-/**Function*************************************************************
-
-  Synopsis    [Finds balanced cut.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Ptr_t * Llb_ManComputeCutLo( Aig_Man_t * p )
-{
-    Vec_Ptr_t * vMinCut;
-    Aig_Obj_t * pObj;
-    int i;
-    vMinCut = Vec_PtrAlloc( 100 );
-    Aig_ManForEachCi( p, pObj, i )
-        Vec_PtrPush( vMinCut, pObj );
-    return vMinCut;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Finds balanced cut.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Ptr_t * Llb_ManComputeCutLi( Aig_Man_t * p )
-{
-    Vec_Ptr_t * vMinCut;
-    Aig_Obj_t * pObj;
-    int i;
-    assert( Saig_ManPoNum(p) == 0 );
-    vMinCut = Vec_PtrAlloc( 100 );
-    Aig_ManIncrementTravId(p);
-    Saig_ManForEachLi( p, pObj, i )
-    {
-        pObj = Aig_ObjFanin0(pObj);
-        if ( Aig_ObjIsConst1(pObj) )
-            continue;
-        if ( Aig_ObjIsTravIdCurrent(p, pObj) )
-            continue;
-        Aig_ObjSetTravIdCurrent(p, pObj);
-        Vec_PtrPush( vMinCut, pObj );
-    }
-    return vMinCut;
-}
-
-
-
-/**Function*************************************************************
-
-  Synopsis    [Finds balanced cut.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManFlowGetObjSet( Aig_Man_t * p, Vec_Ptr_t * vLower, int iStart, int nSize, Vec_Ptr_t * vSet )
-{
-    Aig_Obj_t * pObj;
-    int i;
-    Vec_PtrClear( vSet );
-    for ( i = 0; i < nSize; i++ )
-    {
-        pObj = (Aig_Obj_t *)Vec_PtrEntry( vLower, (iStart + i) % Vec_PtrSize(vLower) );
-        Vec_PtrPush( vSet, pObj );
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Finds balanced cut.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Ptr_t * Llb_ManFlowFindBestCut( Aig_Man_t * p, Vec_Ptr_t * vLower, Vec_Ptr_t * vUpper, int Num )
-{
-    int nVolMin = Aig_ManNodeNum(p) / Num / 2;
-    Vec_Ptr_t * vMinCut;
-    Vec_Ptr_t * vCone, * vSet;
-    Aig_Obj_t * pObj;
-    int i, s, Vol, VolLower, VolUpper, VolCmp;
-    int iBest = -1, iMinCut = ABC_INFINITY, iVolBest = 0;
-
-    Vol = Llb_ManCutVolume( p, vLower, vUpper );
-    assert( Vol > nVolMin );
-    VolCmp = Abc_MinInt( nVolMin, Vol - nVolMin );
-    vCone = Vec_PtrAlloc( 100 );
-    vSet  = Vec_PtrAlloc( 100 );
-    Llb_ManFlowPrepareCut( p, vLower, vUpper );
-    for ( s = 1; s < Aig_ManRegNum(p); s += 5 )
-    {
-        Vec_PtrForEachEntry( Aig_Obj_t *, vLower, pObj, i )
-        {
-            Llb_ManFlowGetObjSet( p, vLower, i, s, vSet );
-            Llb_ManFlowCollectAndMarkCone( p, vSet, vCone );
-            if ( Vec_PtrSize(vCone) == 0 )
-                continue;
-            vMinCut  = Llb_ManFlowCompute( p );
-            Llb_ManFlowUnmarkCone( p, vCone );
-
-            VolLower = Llb_ManCutVolume( p, vLower, vMinCut );
-            VolUpper = Llb_ManCutVolume( p, vMinCut, vUpper );
-            Vol = Abc_MinInt( VolLower, VolUpper );
-            if ( Vol >= VolCmp &&  (iMinCut == -1 || 
-                                    iMinCut >  Vec_PtrSize(vMinCut) || 
-                                   (iMinCut == Vec_PtrSize(vMinCut) && iVolBest < Vol)) )
-            {
-                iBest = i;
-                iMinCut = Vec_PtrSize(vMinCut);
-                iVolBest = Vol;
-            }
-            Vec_PtrFree( vMinCut );
-        }
-        if ( iBest >= 0 )
-            break;
-    }
-    if ( iBest == -1 )
-    {
-        // cleanup
-        Vec_PtrFree( vCone );
-        Vec_PtrFree( vSet );
-        return NULL;
-    }
-    // get the best cut
-    assert( iBest >= 0 );
-    Llb_ManFlowGetObjSet( p, vLower, iBest, s, vSet );
-    Llb_ManFlowCollectAndMarkCone( p, vSet, vCone );
-    vMinCut = Llb_ManFlowCompute( p );
-    Llb_ManFlowUnmarkCone( p, vCone );
-    // cleanup
-    Vec_PtrFree( vCone );
-    Vec_PtrFree( vSet );
-    return vMinCut;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Finds balanced cut.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Ptr_t * Llb_ManComputeCuts( Aig_Man_t * p, int Num, int fVerbose, int fVeryVerbose )
-{
-    int nVolMax = Aig_ManNodeNum(p) / Num;
-    Vec_Ptr_t * vResult, * vMinCut = NULL, * vLower, * vUpper;
-    int i, k, nVol;
-    abctime clk = Abc_Clock();
-    vResult = Vec_PtrAlloc( 100 );
-    Vec_PtrPush( vResult, Llb_ManComputeCutLo(p) );
-    Vec_PtrPush( vResult, Llb_ManComputeCutLi(p) );
-    while ( 1 ) 
-    {
-        // find a place to insert new cut
-        vLower = (Vec_Ptr_t *)Vec_PtrEntry( vResult, 0 );
-        Vec_PtrForEachEntryStart( Vec_Ptr_t *, vResult, vUpper, i, 1 )
-        {
-            nVol = Llb_ManCutVolume( p, vLower, vUpper );
-            if ( nVol <= nVolMax )
-            {
-                vLower = vUpper;
-                continue;
-            }
-
-            if ( fVeryVerbose )
-            Llb_ManCutPrint( p, vLower,  vUpper );
-            vMinCut = Llb_ManFlowFindBestCut( p, vLower, vUpper, Num );
-            if ( vMinCut == NULL )
-            {
-                if ( fVeryVerbose )
-                printf( "Could not break the cut.\n" );
-                if ( fVeryVerbose )
-                printf( "\n" );
-                vLower = vUpper;
-                continue;
-            }
-
-            if ( fVeryVerbose )
-            Llb_ManCutPrint( p, vMinCut, vUpper );
-            if ( fVeryVerbose )
-            Llb_ManCutPrint( p, vLower,  vMinCut );
-            if ( fVeryVerbose )
-            printf( "\n" );
-
-            break;
-        }
-        if ( i == Vec_PtrSize(vResult) )
-            break;
-        // insert vMinCut before vUpper
-        Vec_PtrPush( vResult, NULL );
-        for ( k = Vec_PtrSize(vResult) - 1; k > i; k-- )
-            Vec_PtrWriteEntry( vResult, k, Vec_PtrEntry(vResult, k-1) );
-        Vec_PtrWriteEntry( vResult, i, vMinCut );
-    }
-    if ( fVerbose )
-    {
-        printf( "Finished computing %d partitions.  ", Vec_PtrSize(vResult) - 1 );
-        Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
-        Llb_ManResultPrint( p, vResult );
-    }
-    return vResult;
-}
- 
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_BddSetDefaultParams( Gia_ParLlb_t * p )
-{
-    memset( p, 0, sizeof(Gia_ParLlb_t) );
-    p->nBddMax       =  1000000;
-    p->nIterMax      = 10000000;
-    p->nClusterMax   =       20;
-    p->nHintDepth    =        0;
-    p->HintFirst     =        0;
-    p->fUseFlow      =        0;  // use flow 
-    p->nVolumeMax    =      100;  // max volume
-    p->nVolumeMin    =       30;  // min volume
-    p->fReorder      =        1;
-    p->fIndConstr    =        0;
-    p->fUsePivots    =        0;
-    p->fCluster      =        0;
-    p->fSchedule     =        0;
-    p->fVerbose      =        0;
-    p->fVeryVerbose  =        0;
-    p->fSilent       =        0;
-    p->TimeLimit     =        0;
-//    p->TimeLimit     =        0;
-    p->TimeLimitGlo  =        0;
-    p->TimeTarget    =        0;
-    p->iFrame        =       -1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Finds balanced cut.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ManMinCutTest( Aig_Man_t * pAig, int Num )
-{
-    extern void Llb_BddConstructTest( Aig_Man_t * p, Vec_Ptr_t * vResult );
-    extern void Llb_BddExperiment( Aig_Man_t * pInit, Aig_Man_t * pAig, Gia_ParLlb_t * pPars, Vec_Ptr_t * vResult, Vec_Ptr_t * vMaps );
- 
-
-//    int fVerbose = 1;
-    Gia_ParLlb_t Pars, * pPars = &Pars;
-    Vec_Ptr_t * vResult;//, * vSupps, * vMaps;
-    Aig_Man_t * p;
-
-    Llb_BddSetDefaultParams( pPars );
-
-    p = Aig_ManDupFlopsOnly( pAig );
-//Aig_ManShow( p, 0, NULL );
-    Aig_ManPrintStats( pAig );
-    Aig_ManPrintStats( p );
-    Aig_ManFanoutStart( p );
-
-    vResult = Llb_ManComputeCuts( p, Num, 1, 0 );
-//    vSupps  = Llb_ManCutSupps( p, vResult );
-//    vMaps   = Llb_ManCutMap( p, vResult, vSupps );
-
-//    Llb_BddExperiment( pAig, p, pPars, vResult, vMaps );
-    Llb_CoreExperiment( pAig, p, pPars, vResult, 0 );
-
-//    Vec_VecFree( (Vec_Vec_t *)vMaps );
-//    Vec_VecFree( (Vec_Vec_t *)vSupps );
-    Vec_VecFree( (Vec_Vec_t *)vResult );
-
-    Aig_ManFanoutStop( p );
-    Aig_ManCleanMarkAB( p );
-    Aig_ManStop( p );
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/llb/llb2Image.c b/src/proof/llb/llb2Image.c
deleted file mode 100644
index e245ba36..00000000
--- a/src/proof/llb/llb2Image.c
+++ /dev/null
@@ -1,482 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [llb2Image.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD based reachability.]
-
-  Synopsis    [Computes image using partitioned structure.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: llb2Image.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "llbInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-extern Vec_Ptr_t * Llb_ManCutNodes( Aig_Man_t * p, Vec_Ptr_t * vLower, Vec_Ptr_t * vUpper );
-extern Vec_Ptr_t * Llb_ManCutRange( Aig_Man_t * p, Vec_Ptr_t * vLower, Vec_Ptr_t * vUpper );
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Computes supports of the partitions.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Ptr_t * Llb_ImgSupports( Aig_Man_t * p, Vec_Ptr_t * vDdMans, Vec_Int_t * vStart, Vec_Int_t * vStop, int fAddPis, int fVerbose )
-{
-    Vec_Ptr_t * vSupps;
-    Vec_Int_t * vOne;
-    Aig_Obj_t * pObj;
-    DdManager * dd;
-    DdNode * bSupp, * bTemp;
-    int i, Entry, nSize;
-    nSize  = Cudd_ReadSize( (DdManager *)Vec_PtrEntry( vDdMans, 0 ) );
-    vSupps = Vec_PtrAlloc( 100 );
-    // create initial
-    vOne = Vec_IntStart( nSize );
-    Vec_IntForEachEntry( vStart, Entry, i )
-        Vec_IntWriteEntry( vOne, Entry, 1 );
-    Vec_PtrPush( vSupps, vOne );
-    // create intermediate 
-    Vec_PtrForEachEntry( DdManager *, vDdMans, dd, i )
-    {
-        vOne  = Vec_IntStart( nSize );
-        bSupp = Cudd_Support( dd, dd->bFunc );  Cudd_Ref( bSupp );
-        for ( bTemp = bSupp; bTemp != Cudd_ReadOne(dd); bTemp = cuddT(bTemp) )
-            Vec_IntWriteEntry( vOne, bTemp->index, 1 );
-        Cudd_RecursiveDeref( dd, bSupp );
-        Vec_PtrPush( vSupps, vOne );
-    }
-    // create final
-    vOne = Vec_IntStart( nSize );
-    Vec_IntForEachEntry( vStop, Entry, i )
-        Vec_IntWriteEntry( vOne, Entry, 1 );
-    if ( fAddPis )
-        Saig_ManForEachPi( p, pObj, i )
-            Vec_IntWriteEntry( vOne, Aig_ObjId(pObj), 1 );
-    Vec_PtrPush( vSupps, vOne );
-
-    // print supports
-    assert( nSize == Aig_ManObjNumMax(p) );
-    if ( !fVerbose )
-        return vSupps;
-    Aig_ManForEachObj( p, pObj, i )
-    {
-        int k, Counter = 0;
-        Vec_PtrForEachEntry( Vec_Int_t *, vSupps, vOne, k )
-            Counter += Vec_IntEntry(vOne, i);
-        if ( Counter == 0 ) 
-            continue;
-        printf( "Obj = %4d : ", i );
-        if ( Saig_ObjIsPi(p,pObj) )
-            printf( "pi  " );
-        else if ( Saig_ObjIsLo(p,pObj) )
-            printf( "lo  " );
-        else if ( Saig_ObjIsLi(p,pObj) )
-            printf( "li  " );
-        else if ( Aig_ObjIsNode(pObj) )
-            printf( "and " );
-        Vec_PtrForEachEntry( Vec_Int_t *, vSupps, vOne, k )
-            printf( "%d", Vec_IntEntry(vOne, i) );
-        printf( "\n" );
-    }
-    return vSupps;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Computes quantification schedule.]
-
-  Description [Input array contains supports: 0=starting, ... intermediate...
-  N-1=final. Output arrays contain immediately quantifiable vars (vQuant0)
-  and vars that should be quantified after conjunction (vQuant1).]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ImgSchedule( Vec_Ptr_t * vSupps, Vec_Ptr_t ** pvQuant0, Vec_Ptr_t ** pvQuant1, int fVerbose )
-{
-    Vec_Int_t * vOne;
-    int nVarsAll, Counter, iSupp = -1, Entry, i, k;
-    // start quantification arrays
-    *pvQuant0 = Vec_PtrAlloc( Vec_PtrSize(vSupps) );
-    *pvQuant1 = Vec_PtrAlloc( Vec_PtrSize(vSupps) );
-    Vec_PtrForEachEntry( Vec_Int_t *, vSupps, vOne, k )
-    {
-        Vec_PtrPush( *pvQuant0, Vec_IntAlloc(16) );
-        Vec_PtrPush( *pvQuant1, Vec_IntAlloc(16) );
-    }
-    // count how many times each var appears
-    nVarsAll = Vec_IntSize( (Vec_Int_t *)Vec_PtrEntry(vSupps, 0) );
-    for ( i = 0; i < nVarsAll; i++ )
-    {
-        Counter = 0;
-        Vec_PtrForEachEntry( Vec_Int_t *, vSupps, vOne, k )
-            if ( Vec_IntEntry(vOne, i) )
-            {
-                iSupp = k;
-                Counter++;
-            }
-        if ( Counter == 0 )
-            continue;
-        if ( Counter == 1 )
-            Vec_IntPush( (Vec_Int_t *)Vec_PtrEntry(*pvQuant0, iSupp), i );
-        else // if ( Counter > 1 )
-            Vec_IntPush( (Vec_Int_t *)Vec_PtrEntry(*pvQuant1, iSupp), i );
-    }
-
-    if ( fVerbose )
-    for ( i = 0; i < Vec_PtrSize(vSupps); i++ )
-    {
-        printf( "%2d : Quant0 = ", i );
-        Vec_IntForEachEntry( (Vec_Int_t *)Vec_PtrEntry(*pvQuant0, i), Entry, k )
-            printf( "%d ", Entry );
-        printf( "\n" );
-    }
-
-    if ( fVerbose )
-    for ( i = 0; i < Vec_PtrSize(vSupps); i++ )
-    {
-        printf( "%2d : Quant1 = ", i );
-        Vec_IntForEachEntry( (Vec_Int_t *)Vec_PtrEntry(*pvQuant1, i), Entry, k )
-            printf( "%d ", Entry );
-        printf( "\n" );
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Computes one partition in a separate BDD manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdManager * Llb_ImgPartition( Aig_Man_t * p, Vec_Ptr_t * vLower, Vec_Ptr_t * vUpper, abctime TimeTarget )
-{
-    Vec_Ptr_t * vNodes, * vRange;
-    Aig_Obj_t * pObj;
-    DdManager * dd;
-    DdNode * bBdd0, * bBdd1, * bProd, * bRes, * bTemp;
-    int i;
-
-    dd = Cudd_Init( Aig_ManObjNumMax(p), 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
-    Cudd_AutodynEnable( dd,  CUDD_REORDER_SYMM_SIFT );
-    dd->TimeStop = TimeTarget;
-
-    Vec_PtrForEachEntry( Aig_Obj_t *, vLower, pObj, i )
-        pObj->pData = Cudd_bddIthVar( dd, Aig_ObjId(pObj) );
-
-    vNodes = Llb_ManCutNodes( p, vLower, vUpper );
-    Vec_PtrForEachEntry( Aig_Obj_t *, vNodes, pObj, i )
-    {
-        bBdd0 = Cudd_NotCond( (DdNode *)Aig_ObjFanin0(pObj)->pData, Aig_ObjFaninC0(pObj) );
-        bBdd1 = Cudd_NotCond( (DdNode *)Aig_ObjFanin1(pObj)->pData, Aig_ObjFaninC1(pObj) );
-//        pObj->pData = Cudd_bddAnd( dd, bBdd0, bBdd1 );   Cudd_Ref( (DdNode *)pObj->pData );
-//        pObj->pData = Extra_bddAndTime( dd, bBdd0, bBdd1, TimeTarget );  
-        pObj->pData = Cudd_bddAnd( dd, bBdd0, bBdd1 );  
-        if ( pObj->pData == NULL )
-        {
-            Cudd_Quit( dd );
-            Vec_PtrFree( vNodes );
-            return NULL;
-        }
-        Cudd_Ref( (DdNode *)pObj->pData );
-    }
-
-    vRange = Llb_ManCutRange( p, vLower, vUpper );
-    bRes   = Cudd_ReadOne(dd);   Cudd_Ref( bRes );
-    Vec_PtrForEachEntry( Aig_Obj_t *, vRange, pObj, i )
-    {
-        assert( Aig_ObjIsNode(pObj) );
-        bProd = Cudd_bddXnor( dd, Cudd_bddIthVar(dd, Aig_ObjId(pObj)), (DdNode *)pObj->pData );   Cudd_Ref( bProd );
-//        bRes  = Cudd_bddAnd( dd, bTemp = bRes, bProd ); Cudd_Ref( bRes );
-//        bRes  = Extra_bddAndTime( dd, bTemp = bRes, bProd, TimeTarget );  
-        bRes  = Cudd_bddAnd( dd, bTemp = bRes, bProd );  
-        if ( bRes == NULL )
-        {
-            Cudd_Quit( dd );
-            Vec_PtrFree( vRange );
-            Vec_PtrFree( vNodes );
-            return NULL;
-        }        
-        Cudd_Ref( bRes );
-        Cudd_RecursiveDeref( dd, bTemp );
-        Cudd_RecursiveDeref( dd, bProd );
-    }
-    Vec_PtrForEachEntry( Aig_Obj_t *, vNodes, pObj, i )
-        Cudd_RecursiveDeref( dd, (DdNode *)pObj->pData );
-
-    Vec_PtrFree( vRange );
-    Vec_PtrFree( vNodes );
-    Cudd_AutodynDisable( dd );
-//    Cudd_RecursiveDeref( dd, bRes );
-//    Extra_StopManager( dd );
-    dd->bFunc = bRes;
-    dd->TimeStop = 0;
-    return dd;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Derives positive cube composed of nodes IDs.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb_ImgComputeCube( Aig_Man_t * pAig, Vec_Int_t * vNodeIds, DdManager * dd )
-{
-    DdNode * bProd, * bTemp;
-    Aig_Obj_t * pObj;
-    int i;
-    abctime TimeStop;
-    TimeStop = dd->TimeStop; dd->TimeStop = 0;
-    bProd = Cudd_ReadOne(dd);   Cudd_Ref( bProd );
-    Aig_ManForEachObjVec( vNodeIds, pAig, pObj, i )
-    {
-        bProd  = Cudd_bddAnd( dd, bTemp = bProd, Cudd_bddIthVar(dd, Aig_ObjId(pObj)) ); Cudd_Ref( bProd );
-        Cudd_RecursiveDeref( dd, bTemp );
-    }
-    Cudd_Deref( bProd );
-    dd->TimeStop = TimeStop;
-    return bProd;
-} 
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ImgQuantifyFirst( Aig_Man_t * pAig, Vec_Ptr_t * vDdMans, Vec_Ptr_t * vQuant0, int fVerbose )
-{
-    DdManager * dd;
-    DdNode * bProd, * bRes, * bTemp;
-    int i;
-    abctime clk = Abc_Clock();
-    Vec_PtrForEachEntry( DdManager *, vDdMans, dd, i )
-    {
-        // remember unquantified ones
-        assert( dd->bFunc2 == NULL );
-        dd->bFunc2 = dd->bFunc;   Cudd_Ref( dd->bFunc2 );
-
-        Cudd_AutodynEnable( dd, CUDD_REORDER_SYMM_SIFT );
-
-        bRes = dd->bFunc;
-        if ( fVerbose )
-            Abc_Print( 1, "Part %2d : Init =%5d. ", i, Cudd_DagSize(bRes) );
-        bProd = Llb_ImgComputeCube( pAig, (Vec_Int_t *)Vec_PtrEntry(vQuant0, i+1), dd );   Cudd_Ref( bProd );
-        bRes  = Cudd_bddExistAbstract( dd, bTemp = bRes, bProd );                          Cudd_Ref( bRes );
-        Cudd_RecursiveDeref( dd, bTemp );
-        Cudd_RecursiveDeref( dd, bProd );
-        dd->bFunc = bRes;
-
-        Cudd_AutodynDisable( dd );
-
-        if ( fVerbose )
-            Abc_Print( 1, "Quant =%5d. ", Cudd_DagSize(bRes) );
-        Cudd_ReduceHeap( dd, CUDD_REORDER_SYMM_SIFT, 100 );
-        if ( fVerbose ) 
-            Abc_Print( 1, "Reo = %5d. ", Cudd_DagSize(bRes) );
-        Cudd_ReduceHeap( dd, CUDD_REORDER_SYMM_SIFT, 100 );
-        if ( fVerbose ) 
-            Abc_Print( 1, "Reo = %5d.  ", Cudd_DagSize(bRes) );
-        if ( fVerbose ) 
-            Abc_Print( 1, "Supp = %3d.  ", Cudd_SupportSize(dd, bRes) );
-        if ( fVerbose ) 
-            Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
-
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_ImgQuantifyReset( Vec_Ptr_t * vDdMans )
-{
-    DdManager * dd;
-    int i;
-    Vec_PtrForEachEntry( DdManager *, vDdMans, dd, i )
-    {
-        assert( dd->bFunc2 != NULL );
-        Cudd_RecursiveDeref( dd, dd->bFunc );
-        dd->bFunc = dd->bFunc2;
-        dd->bFunc2 = NULL;
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Computes image of the initial set of states.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb_ImgComputeImage( Aig_Man_t * pAig, Vec_Ptr_t * vDdMans, DdManager * dd, DdNode * bInit, 
-    Vec_Ptr_t * vQuant0, Vec_Ptr_t * vQuant1, Vec_Int_t * vDriRefs, 
-    abctime TimeTarget, int fBackward, int fReorder, int fVerbose )
-{
-//    int fCheckSupport = 0;
-    DdManager * ddPart;
-    DdNode * bImage, * bGroup, * bCube, * bTemp;
-    int i;
-    abctime clk, clk0 = Abc_Clock();
-
-    bImage = bInit;  Cudd_Ref( bImage );
-    if ( fBackward )
-    {
-        // change polarity
-        bCube  = Llb_DriverPhaseCube( pAig, vDriRefs, dd );                Cudd_Ref( bCube );
-        bImage = Extra_bddChangePolarity( dd, bTemp = bImage, bCube );     Cudd_Ref( bImage );
-        Cudd_RecursiveDeref( dd, bTemp );
-        Cudd_RecursiveDeref( dd, bCube );
-    }
-    else
-    {
-        // quantify unique vriables
-        bCube  = Llb_ImgComputeCube( pAig, (Vec_Int_t *)Vec_PtrEntry(vQuant0, 0), dd ); Cudd_Ref( bCube );
-        bImage = Cudd_bddExistAbstract( dd, bTemp = bImage, bCube );                    
-        if ( bImage == NULL )
-        {
-            Cudd_RecursiveDeref( dd, bTemp );
-            Cudd_RecursiveDeref( dd, bCube );
-            return NULL;
-        }
-        Cudd_Ref( bImage );
-        Cudd_RecursiveDeref( dd, bTemp );
-        Cudd_RecursiveDeref( dd, bCube );
-    }
-    // perform image computation
-    Vec_PtrForEachEntry( DdManager *, vDdMans, ddPart, i )
-    {
-        clk = Abc_Clock();
-if ( fVerbose )
-printf( "   %2d : ", i );
-        // transfer the BDD from the group manager to the main manager
-        bGroup = Cudd_bddTransfer( ddPart, dd, ddPart->bFunc );                           
-        if ( bGroup == NULL )
-            return NULL;
-        Cudd_Ref( bGroup );
-if ( fVerbose )
-printf( "Pt0 =%6d. Pt1 =%6d. ", Cudd_DagSize(ddPart->bFunc), Cudd_DagSize(bGroup) );
-        // perform partial product
-        bCube  = Llb_ImgComputeCube( pAig, (Vec_Int_t *)Vec_PtrEntry(vQuant1, i+1), dd ); Cudd_Ref( bCube );
-//        bImage = Cudd_bddAndAbstract( dd, bTemp = bImage, bGroup, bCube );                
-//        bImage = Extra_bddAndAbstractTime( dd, bTemp = bImage, bGroup, bCube, TimeTarget );  
-        bImage = Cudd_bddAndAbstract( dd, bTemp = bImage, bGroup, bCube );  
-        if ( bImage == NULL )
-        {
-            Cudd_RecursiveDeref( dd, bTemp );
-            Cudd_RecursiveDeref( dd, bCube );
-            Cudd_RecursiveDeref( dd, bGroup );
-            return NULL;
-        }
-        Cudd_Ref( bImage );
-
-if ( fVerbose )
-printf( "Im0 =%6d. Im1 =%6d. ", Cudd_DagSize(bTemp), Cudd_DagSize(bImage) );
-//printf("\n"); Extra_bddPrintSupport(dd, bImage); printf("\n");
-        Cudd_RecursiveDeref( dd, bTemp );
-        Cudd_RecursiveDeref( dd, bCube );
-        Cudd_RecursiveDeref( dd, bGroup );
-
-//        Cudd_ReduceHeap( dd, CUDD_REORDER_SYMM_SIFT, 100 );
-//        Abc_Print( 1, "Reo =%6d.  ", Cudd_DagSize(bImage) );
-
-if ( fVerbose )
-printf( "Supp =%3d. ", Cudd_SupportSize(dd, bImage) );
-if ( fVerbose )
-Abc_PrintTime( 1, "T", Abc_Clock() - clk );
-    }
-
-    if ( !fBackward )
-    {
-        // change polarity
-        bCube  = Llb_DriverPhaseCube( pAig, vDriRefs, dd );                Cudd_Ref( bCube );
-        bImage = Extra_bddChangePolarity( dd, bTemp = bImage, bCube );     Cudd_Ref( bImage );
-        Cudd_RecursiveDeref( dd, bTemp );
-        Cudd_RecursiveDeref( dd, bCube );
-    }
-    else
-    {
-        // quantify unique vriables
-        bCube  = Llb_ImgComputeCube( pAig, (Vec_Int_t *)Vec_PtrEntry(vQuant0, 0), dd ); Cudd_Ref( bCube );
-        bImage = Cudd_bddExistAbstract( dd, bTemp = bImage, bCube );                    Cudd_Ref( bImage );
-        Cudd_RecursiveDeref( dd, bTemp );
-        Cudd_RecursiveDeref( dd, bCube );
-    }
-
-    if ( fReorder )
-    {
-    if ( fVerbose )
-    Abc_Print( 1, "        Reordering... Before =%5d. ", Cudd_DagSize(bImage) );
-    Cudd_ReduceHeap( dd, CUDD_REORDER_SYMM_SIFT, 100 );
-    if ( fVerbose )
-    Abc_Print( 1, "After =%5d. ", Cudd_DagSize(bImage) );
-//    Cudd_ReduceHeap( dd, CUDD_REORDER_SYMM_SIFT, 100 );
-//    Abc_Print( 1, "After =%5d.  ", Cudd_DagSize(bImage) );
-    if ( fVerbose )
-    Abc_PrintTime( 1, "Time", Abc_Clock() - clk0 );
-//    Abc_Print( 1, "\n" );
-    }
-
-    Cudd_Deref( bImage );
-    return bImage;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/llb/llb3Image.c b/src/proof/llb/llb3Image.c
deleted file mode 100644
index 72c6120a..00000000
--- a/src/proof/llb/llb3Image.c
+++ /dev/null
@@ -1,1095 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [llb3Image.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD based reachability.]
-
-  Synopsis    [Computes image using partitioned structure.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: llb3Image.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "llbInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-typedef struct Llb_Var_t_ Llb_Var_t;
-struct Llb_Var_t_ 
-{
-    int           iVar;      // variable number
-    int           nScore;    // variable score
-    Vec_Int_t *   vParts;    // partitions
-};
-
-typedef struct Llb_Prt_t_ Llb_Prt_t;
-struct Llb_Prt_t_ 
-{
-    int           iPart;     // partition number
-    int           nSize;     // the number of BDD nodes
-    DdNode *      bFunc;     // the partition
-    Vec_Int_t *   vVars;     // support
-};
-
-typedef struct Llb_Mgr_t_ Llb_Mgr_t;
-struct Llb_Mgr_t_
-{
-    Aig_Man_t *   pAig;      // AIG manager
-    Vec_Ptr_t *   vLeaves;   // leaves in the AIG manager
-    Vec_Ptr_t *   vRoots;    // roots in the AIG manager
-    DdManager *   dd;        // working BDD manager
-    int *         pVars2Q;   // variables to quantify
-    // internal
-    Llb_Prt_t **  pParts;    // partitions
-    Llb_Var_t **  pVars;     // variables
-    int           iPartFree; // next free partition
-    int           nVars;     // the number of BDD variables
-    int           nSuppMax;  // maximum support size
-    // temporary
-    int *         pSupp;     // temporary support storage
-};
-
-static inline Llb_Var_t * Llb_MgrVar( Llb_Mgr_t * p, int i )   { return p->pVars[i];  }
-static inline Llb_Prt_t * Llb_MgrPart( Llb_Mgr_t * p, int i )  { return p->pParts[i]; }
-
-// iterator over vars
-#define Llb_MgrForEachVar( p, pVar, i )     \
-    for ( i = 0; (i < p->nVars) && (((pVar) = Llb_MgrVar(p, i)), 1); i++ ) if ( pVar == NULL ) {} else
-// iterator over parts
-#define Llb_MgrForEachPart( p, pPart, i )   \
-    for ( i = 0; (i < p->iPartFree) && (((pPart) = Llb_MgrPart(p, i)), 1); i++ ) if ( pPart == NULL ) {} else
-
-// iterator over vars of one partition
-#define Llb_PartForEachVar( p, pPart, pVar, i )   \
-    for ( i = 0; (i < Vec_IntSize(pPart->vVars)) && (((pVar) = Llb_MgrVar(p, Vec_IntEntry(pPart->vVars,i))), 1); i++ )
-// iterator over parts of one variable
-#define Llb_VarForEachPart( p, pVar, pPart, i )   \
-    for ( i = 0; (i < Vec_IntSize(pVar->vParts)) && (((pPart) = Llb_MgrPart(p, Vec_IntEntry(pVar->vParts,i))), 1); i++ )
-
-// statistics
-abctime timeBuild, timeAndEx, timeOther;
-int nSuppMax;
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Removes one variable.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_NonlinRemoveVar( Llb_Mgr_t * p, Llb_Var_t * pVar )
-{
-    assert( p->pVars[pVar->iVar] == pVar );
-    p->pVars[pVar->iVar] = NULL;
-    Vec_IntFree( pVar->vParts );
-    ABC_FREE( pVar );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Removes one partition.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_NonlinRemovePart( Llb_Mgr_t * p, Llb_Prt_t * pPart )
-{
-    assert( p->pParts[pPart->iPart] == pPart );
-    p->pParts[pPart->iPart] = NULL;
-    Vec_IntFree( pPart->vVars );
-    Cudd_RecursiveDeref( p->dd, pPart->bFunc );
-    ABC_FREE( pPart );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Create cube with singleton variables.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb_NonlinCreateCube1( Llb_Mgr_t * p, Llb_Prt_t * pPart )
-{
-    DdNode * bCube, * bTemp;
-    Llb_Var_t * pVar;
-    int i;
-    abctime TimeStop;
-    TimeStop = p->dd->TimeStop; p->dd->TimeStop = 0;
-    bCube = Cudd_ReadOne(p->dd);   Cudd_Ref( bCube );
-    Llb_PartForEachVar( p, pPart, pVar, i )
-    {
-        assert( Vec_IntSize(pVar->vParts) > 0 );
-        if ( Vec_IntSize(pVar->vParts) != 1 )
-            continue;
-        assert( Vec_IntEntry(pVar->vParts, 0) == pPart->iPart );
-        bCube = Cudd_bddAnd( p->dd, bTemp = bCube, Cudd_bddIthVar(p->dd, pVar->iVar) );    Cudd_Ref( bCube );
-        Cudd_RecursiveDeref( p->dd, bTemp );
-    }
-    Cudd_Deref( bCube );
-    p->dd->TimeStop = TimeStop;
-    return bCube;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Create cube of variables appearing only in two partitions.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb_NonlinCreateCube2( Llb_Mgr_t * p, Llb_Prt_t * pPart1, Llb_Prt_t * pPart2 )
-{
-    DdNode * bCube, * bTemp;
-    Llb_Var_t * pVar;
-    int i;
-    abctime TimeStop;
-    TimeStop = p->dd->TimeStop; p->dd->TimeStop = 0;
-    bCube = Cudd_ReadOne(p->dd);   Cudd_Ref( bCube );
-    Llb_PartForEachVar( p, pPart1, pVar, i )
-    {
-        assert( Vec_IntSize(pVar->vParts) > 0 );
-        if ( Vec_IntSize(pVar->vParts) != 2 )
-            continue;
-        if ( (Vec_IntEntry(pVar->vParts, 0) == pPart1->iPart && Vec_IntEntry(pVar->vParts, 1) == pPart2->iPart) ||
-             (Vec_IntEntry(pVar->vParts, 0) == pPart2->iPart && Vec_IntEntry(pVar->vParts, 1) == pPart1->iPart) )
-        {
-            bCube = Cudd_bddAnd( p->dd, bTemp = bCube, Cudd_bddIthVar(p->dd, pVar->iVar) );   Cudd_Ref( bCube );
-            Cudd_RecursiveDeref( p->dd, bTemp );
-        }
-    }
-    Cudd_Deref( bCube );
-    p->dd->TimeStop = TimeStop;
-    return bCube;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns 1 if partition has singleton variables.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_NonlinHasSingletonVars( Llb_Mgr_t * p, Llb_Prt_t * pPart )
-{
-    Llb_Var_t * pVar;
-    int i;
-    Llb_PartForEachVar( p, pPart, pVar, i )
-        if ( Vec_IntSize(pVar->vParts) == 1 )
-            return 1;
-    return 0;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns 1 if partition has singleton variables.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_NonlinPrint( Llb_Mgr_t * p )
-{
-    Llb_Prt_t * pPart;
-    Llb_Var_t * pVar;
-    int i, k;
-    printf( "\n" );
-    Llb_MgrForEachVar( p, pVar, i )
-    {
-        printf( "Var %3d : ", i );
-        Llb_VarForEachPart( p, pVar, pPart, k )
-            printf( "%d ", pPart->iPart );
-        printf( "\n" );
-    }
-    Llb_MgrForEachPart( p, pPart, i )
-    {
-        printf( "Part %3d : ", i );
-        Llb_PartForEachVar( p, pPart, pVar, k )
-            printf( "%d ", pVar->iVar );
-        printf( "\n" );
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Quantifies singles belonging to one partition.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_NonlinQuantify1( Llb_Mgr_t * p, Llb_Prt_t * pPart, int fSubset )
-{
-    Llb_Var_t * pVar;
-    Llb_Prt_t * pTemp;
-    Vec_Ptr_t * vSingles;
-    DdNode * bCube, * bTemp;
-    int i, RetValue, nSizeNew;
-    if ( fSubset )
-    {        
-        int Length;
-//        int nSuppSize = Cudd_SupportSize( p->dd, pPart->bFunc );
-//        pPart->bFunc = Cudd_SubsetHeavyBranch( p->dd, bTemp = pPart->bFunc, nSuppSize, 3*pPart->nSize/4 );  Cudd_Ref( pPart->bFunc );
-        pPart->bFunc = Cudd_LargestCube( p->dd, bTemp = pPart->bFunc, &Length );  Cudd_Ref( pPart->bFunc );
-
-        printf( "Subsetting %3d : ", pPart->iPart );
-        printf( "(Supp =%3d  Node =%5d) -> ", Cudd_SupportSize(p->dd, bTemp),        Cudd_DagSize(bTemp) );
-        printf( "(Supp =%3d  Node =%5d)\n",   Cudd_SupportSize(p->dd, pPart->bFunc), Cudd_DagSize(pPart->bFunc) );
-
-        RetValue = (Cudd_DagSize(bTemp) == Cudd_DagSize(pPart->bFunc));
-
-        Cudd_RecursiveDeref( p->dd, bTemp );
-
-        if ( RetValue )
-            return 1;
-    }
-    else
-    {
-        // create cube to be quantified
-        bCube = Llb_NonlinCreateCube1( p, pPart );   Cudd_Ref( bCube );
-//        assert( !Cudd_IsConstant(bCube) );
-        // derive new function
-        pPart->bFunc = Cudd_bddExistAbstract( p->dd, bTemp = pPart->bFunc, bCube );  Cudd_Ref( pPart->bFunc );
-        Cudd_RecursiveDeref( p->dd, bTemp );
-        Cudd_RecursiveDeref( p->dd, bCube );
-    }
-    // get support
-    vSingles = Vec_PtrAlloc( 0 );
-    nSizeNew = Cudd_DagSize(pPart->bFunc);
-    Extra_SupportArray( p->dd, pPart->bFunc, p->pSupp );
-    Llb_PartForEachVar( p, pPart, pVar, i )
-        if ( p->pSupp[pVar->iVar] )
-        {
-            assert( Vec_IntSize(pVar->vParts) > 1 );
-            pVar->nScore -= pPart->nSize - nSizeNew;
-        }
-        else
-        {
-            RetValue = Vec_IntRemove( pVar->vParts, pPart->iPart );
-            assert( RetValue );
-            pVar->nScore -= pPart->nSize;
-            if ( Vec_IntSize(pVar->vParts) == 0 )
-                Llb_NonlinRemoveVar( p, pVar );
-            else if ( Vec_IntSize(pVar->vParts) == 1 )
-                Vec_PtrPushUnique( vSingles, Llb_MgrPart(p, Vec_IntEntry(pVar->vParts,0)) );
-        }
-
-    // update partition
-    pPart->nSize = nSizeNew;
-    Vec_IntClear( pPart->vVars );
-    for ( i = 0; i < p->nVars; i++ )
-        if ( p->pSupp[i] && p->pVars2Q[i] )
-            Vec_IntPush( pPart->vVars, i );
-    // remove other variables
-    Vec_PtrForEachEntry( Llb_Prt_t *, vSingles, pTemp, i )
-        Llb_NonlinQuantify1( p, pTemp, 0 );
-    Vec_PtrFree( vSingles );
-    return 0;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Quantifies singles belonging to one partition.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_NonlinQuantify2( Llb_Mgr_t * p, Llb_Prt_t * pPart1, Llb_Prt_t * pPart2 )
-{
-    int fVerbose = 0;
-    Llb_Var_t * pVar;
-    Llb_Prt_t * pTemp;
-    Vec_Ptr_t * vSingles;
-    DdNode * bCube, * bFunc;
-    int i, RetValue, nSuppSize;
-//    int iPart1 = pPart1->iPart;
-//    int iPart2 = pPart2->iPart;
-
-    // create cube to be quantified
-    bCube = Llb_NonlinCreateCube2( p, pPart1, pPart2 );   Cudd_Ref( bCube );
-if ( fVerbose )
-{
-printf( "\n" );
-printf( "\n" );
-Llb_NonlinPrint( p );
-printf( "Conjoining partitions %d and %d.\n", pPart1->iPart, pPart2->iPart );
-Extra_bddPrintSupport( p->dd, bCube );  printf( "\n" );
-}
- 
-    // derive new function
-//    bFunc = Cudd_bddAndAbstract( p->dd, pPart1->bFunc, pPart2->bFunc, bCube );  Cudd_Ref( bFunc );
-/*
-    bFunc = Cudd_bddAndAbstractLimit( p->dd, pPart1->bFunc, pPart2->bFunc, bCube, Limit );  
-    if ( bFunc == NULL )
-    {
-        int RetValue;
-        Cudd_RecursiveDeref( p->dd, bCube );
-        if ( pPart1->nSize < pPart2->nSize )
-            RetValue = Llb_NonlinQuantify1( p, pPart1, 1 );
-        else
-            RetValue = Llb_NonlinQuantify1( p, pPart2, 1 );
-        if ( RetValue )
-            Limit = Limit + 1000;
-        Llb_NonlinQuantify2( p, pPart1, pPart2 );
-        return 0;
-    }
-    Cudd_Ref( bFunc );
-*/
-
-//    bFunc = Extra_bddAndAbstractTime( p->dd, pPart1->bFunc, pPart2->bFunc, bCube, TimeOut );  
-    bFunc = Cudd_bddAndAbstract( p->dd, pPart1->bFunc, pPart2->bFunc, bCube );  
-    if ( bFunc == NULL )
-    {
-        Cudd_RecursiveDeref( p->dd, bCube );
-        return 0;
-    }
-    Cudd_Ref( bFunc );
-    Cudd_RecursiveDeref( p->dd, bCube );
-
-    // create new partition
-    pTemp = p->pParts[p->iPartFree] = ABC_CALLOC( Llb_Prt_t, 1 );
-    pTemp->iPart = p->iPartFree++;
-    pTemp->nSize = Cudd_DagSize(bFunc);
-    pTemp->bFunc = bFunc;
-    pTemp->vVars = Vec_IntAlloc( 8 );
-    // update variables
-    Llb_PartForEachVar( p, pPart1, pVar, i )
-    {
-        RetValue = Vec_IntRemove( pVar->vParts, pPart1->iPart );
-        assert( RetValue );
-        pVar->nScore -= pPart1->nSize;
-    }
-    // update variables
-    Llb_PartForEachVar( p, pPart2, pVar, i )
-    {
-        RetValue = Vec_IntRemove( pVar->vParts, pPart2->iPart );
-        assert( RetValue );
-        pVar->nScore -= pPart2->nSize;
-    }
-    // add variables to the new partition
-    nSuppSize = 0;
-    Extra_SupportArray( p->dd, bFunc, p->pSupp );
-    for ( i = 0; i < p->nVars; i++ )
-    {
-        nSuppSize += p->pSupp[i];
-        if ( p->pSupp[i] && p->pVars2Q[i] )
-        {
-            pVar = Llb_MgrVar( p, i );
-            pVar->nScore += pTemp->nSize;
-            Vec_IntPush( pVar->vParts, pTemp->iPart );
-            Vec_IntPush( pTemp->vVars, i );
-        }
-    }
-    p->nSuppMax = Abc_MaxInt( p->nSuppMax, nSuppSize ); 
-    // remove variables and collect partitions with singleton variables
-    vSingles = Vec_PtrAlloc( 0 );
-    Llb_PartForEachVar( p, pPart1, pVar, i )
-    {
-        if ( Vec_IntSize(pVar->vParts) == 0 )
-            Llb_NonlinRemoveVar( p, pVar );
-        else if ( Vec_IntSize(pVar->vParts) == 1 )
-        {
-            if ( fVerbose )
-                printf( "Adding partition %d because of var %d.\n", 
-                    Llb_MgrPart(p, Vec_IntEntry(pVar->vParts,0))->iPart, pVar->iVar );
-            Vec_PtrPushUnique( vSingles, Llb_MgrPart(p, Vec_IntEntry(pVar->vParts,0)) );
-        }
-    }
-    Llb_PartForEachVar( p, pPart2, pVar, i )
-    {
-        if ( pVar == NULL )
-            continue;
-        if ( Vec_IntSize(pVar->vParts) == 0 )
-            Llb_NonlinRemoveVar( p, pVar );
-        else if ( Vec_IntSize(pVar->vParts) == 1 )
-        {
-            if ( fVerbose )
-                printf( "Adding partition %d because of var %d.\n", 
-                    Llb_MgrPart(p, Vec_IntEntry(pVar->vParts,0))->iPart, pVar->iVar );
-            Vec_PtrPushUnique( vSingles, Llb_MgrPart(p, Vec_IntEntry(pVar->vParts,0)) );
-        }
-    }
-    // remove partitions
-    Llb_NonlinRemovePart( p, pPart1 );
-    Llb_NonlinRemovePart( p, pPart2 );
-    // remove other variables
-if ( fVerbose )
-Llb_NonlinPrint( p );
-    Vec_PtrForEachEntry( Llb_Prt_t *, vSingles, pTemp, i )
-    {
-if ( fVerbose )
-printf( "Updating partitiong %d with singlton vars.\n", pTemp->iPart );
-        Llb_NonlinQuantify1( p, pTemp, 0 );
-    }
-if ( fVerbose )
-Llb_NonlinPrint( p );
-    Vec_PtrFree( vSingles );
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Computes volume of the cut.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_NonlinCutNodes_rec( Aig_Man_t * p, Aig_Obj_t * pObj, Vec_Ptr_t * vNodes )
-{
-    if ( Aig_ObjIsTravIdCurrent(p, pObj) )
-        return;
-    Aig_ObjSetTravIdCurrent(p, pObj);
-    if ( Saig_ObjIsLi(p, pObj) )
-    {
-        Llb_NonlinCutNodes_rec(p, Aig_ObjFanin0(pObj), vNodes);
-        return;
-    }
-    if ( Aig_ObjIsConst1(pObj) )
-        return;
-    assert( Aig_ObjIsNode(pObj) );
-    Llb_NonlinCutNodes_rec(p, Aig_ObjFanin0(pObj), vNodes);
-    Llb_NonlinCutNodes_rec(p, Aig_ObjFanin1(pObj), vNodes);
-    Vec_PtrPush( vNodes, pObj );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Computes volume of the cut.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Ptr_t * Llb_NonlinCutNodes( Aig_Man_t * p, Vec_Ptr_t * vLower, Vec_Ptr_t * vUpper )
-{
-    Vec_Ptr_t * vNodes;
-    Aig_Obj_t * pObj;
-    int i;
-    // mark the lower cut with the traversal ID
-    Aig_ManIncrementTravId(p);
-    Vec_PtrForEachEntry( Aig_Obj_t *, vLower, pObj, i )
-        Aig_ObjSetTravIdCurrent( p, pObj );
-    // count the upper cut
-    vNodes = Vec_PtrAlloc( 100 );
-    Vec_PtrForEachEntry( Aig_Obj_t *, vUpper, pObj, i )
-        Llb_NonlinCutNodes_rec( p, pObj, vNodes );
-    return vNodes;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns array of BDDs for the roots in terms of the leaves.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Ptr_t * Llb_NonlinBuildBdds( Aig_Man_t * p, Vec_Ptr_t * vLower, Vec_Ptr_t * vUpper, DdManager * dd )
-{
-    Vec_Ptr_t * vNodes, * vResult;
-    Aig_Obj_t * pObj;
-    DdNode * bBdd0, * bBdd1, * bProd;
-    int i, k;
-
-    Aig_ManConst1(p)->pData = Cudd_ReadOne( dd );
-    Vec_PtrForEachEntry( Aig_Obj_t *, vLower, pObj, i )
-        pObj->pData = Cudd_bddIthVar( dd, Aig_ObjId(pObj) );
-
-    vNodes = Llb_NonlinCutNodes( p, vLower, vUpper );
-    Vec_PtrForEachEntry( Aig_Obj_t *, vNodes, pObj, i )
-    {
-        bBdd0 = Cudd_NotCond( (DdNode *)Aig_ObjFanin0(pObj)->pData, Aig_ObjFaninC0(pObj) );
-        bBdd1 = Cudd_NotCond( (DdNode *)Aig_ObjFanin1(pObj)->pData, Aig_ObjFaninC1(pObj) );
-//        pObj->pData = Extra_bddAndTime( dd, bBdd0, bBdd1, TimeOut );
-        pObj->pData = Cudd_bddAnd( dd, bBdd0, bBdd1 );
-        if ( pObj->pData == NULL )
-        {
-            Vec_PtrForEachEntryStop( Aig_Obj_t *, vNodes, pObj, k, i )
-                if ( pObj->pData )
-                    Cudd_RecursiveDeref( dd, (DdNode *)pObj->pData );
-            Vec_PtrFree( vNodes );
-            return NULL;
-        }
-        Cudd_Ref( (DdNode *)pObj->pData );
-    }
-
-    vResult = Vec_PtrAlloc( 100 );
-    Vec_PtrForEachEntry( Aig_Obj_t *, vUpper, pObj, i )
-    {
-        if ( Aig_ObjIsNode(pObj) )
-        {
-            bProd = Cudd_bddXnor( dd, Cudd_bddIthVar(dd, Aig_ObjId(pObj)), (DdNode *)pObj->pData );  Cudd_Ref( bProd );
-        }
-        else
-        {
-            assert( Saig_ObjIsLi(p, pObj) );
-            bBdd0 = Cudd_NotCond( (DdNode *)Aig_ObjFanin0(pObj)->pData, Aig_ObjFaninC0(pObj) );
-            bProd = Cudd_bddXnor( dd, Cudd_bddIthVar(dd, Aig_ObjId(pObj)), bBdd0 );                  Cudd_Ref( bProd );
-        }
-        Vec_PtrPush( vResult, bProd );
-    }
-    Vec_PtrForEachEntry( Aig_Obj_t *, vNodes, pObj, i )
-        Cudd_RecursiveDeref( dd, (DdNode *)pObj->pData );
-
-    Vec_PtrFree( vNodes );
-    return vResult;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Starts non-linear quantification scheduling.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_NonlinAddPair( Llb_Mgr_t * p, DdNode * bFunc, int iPart, int iVar )
-{
-    if ( p->pVars[iVar] == NULL )
-    {
-        p->pVars[iVar] = ABC_CALLOC( Llb_Var_t, 1 );
-        p->pVars[iVar]->iVar   = iVar;
-        p->pVars[iVar]->nScore = 0;
-        p->pVars[iVar]->vParts = Vec_IntAlloc( 8 );
-    }
-    Vec_IntPush( p->pVars[iVar]->vParts, iPart );
-    Vec_IntPush( p->pParts[iPart]->vVars, iVar );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Starts non-linear quantification scheduling.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_NonlinAddPartition( Llb_Mgr_t * p, int i, DdNode * bFunc )
-{
-    int k, nSuppSize;
-    assert( !Cudd_IsConstant(bFunc) );
-    // create partition
-    p->pParts[i] = ABC_CALLOC( Llb_Prt_t, 1 );
-    p->pParts[i]->iPart = i;
-    p->pParts[i]->bFunc = bFunc;
-    p->pParts[i]->vVars = Vec_IntAlloc( 8 );
-    // add support dependencies
-    nSuppSize = 0;
-    Extra_SupportArray( p->dd, bFunc, p->pSupp );
-    for ( k = 0; k < p->nVars; k++ )
-    {
-        nSuppSize += p->pSupp[k];
-        if ( p->pSupp[k] && p->pVars2Q[k] )
-            Llb_NonlinAddPair( p, bFunc, i, k );
-    }
-    p->nSuppMax = Abc_MaxInt( p->nSuppMax, nSuppSize ); 
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Starts non-linear quantification scheduling.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_NonlinStart( Llb_Mgr_t * p )
-{
-    Vec_Ptr_t * vRootBdds;
-    DdNode * bFunc;
-    int i;
-    // create and collect BDDs
-    vRootBdds = Llb_NonlinBuildBdds( p->pAig, p->vLeaves, p->vRoots, p->dd ); // come referenced
-    if ( vRootBdds == NULL )
-        return 0;
-    // add pairs (refs are consumed inside)
-    Vec_PtrForEachEntry( DdNode *, vRootBdds, bFunc, i )
-        Llb_NonlinAddPartition( p, i, bFunc );
-    Vec_PtrFree( vRootBdds );
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Checks that each var appears in at least one partition.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-**********************************************************************/
-void Llb_NonlinCheckVars( Llb_Mgr_t * p )
-{
-    Llb_Var_t * pVar;
-    int i;
-    Llb_MgrForEachVar( p, pVar, i )
-        assert( Vec_IntSize(pVar->vParts) > 1 );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Find next partition to quantify]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_NonlinNextPartitions( Llb_Mgr_t * p, Llb_Prt_t ** ppPart1, Llb_Prt_t ** ppPart2 )
-{
-    Llb_Var_t * pVar, * pVarBest = NULL;
-    Llb_Prt_t * pPart, * pPart1Best = NULL, * pPart2Best = NULL;
-    int i;
-    Llb_NonlinCheckVars( p );
-    // find variable with minimum score
-    Llb_MgrForEachVar( p, pVar, i )
-        if ( pVarBest == NULL || pVarBest->nScore > pVar->nScore )
-            pVarBest = pVar;
-    if ( pVarBest == NULL )
-        return 0;
-    // find two partitions with minimum size
-    Llb_VarForEachPart( p, pVarBest, pPart, i )
-    {
-        if ( pPart1Best == NULL )
-            pPart1Best = pPart;
-        else if ( pPart2Best == NULL )
-            pPart2Best = pPart;
-        else if ( pPart1Best->nSize > pPart->nSize || pPart2Best->nSize > pPart->nSize )
-        {
-            if ( pPart1Best->nSize > pPart2Best->nSize )
-                pPart1Best = pPart;
-            else
-                pPart2Best = pPart;
-        }
-    }
-    *ppPart1 = pPart1Best;
-    *ppPart2 = pPart2Best;
-    return 1; 
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Reorders BDDs in the working manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_NonlinReorder( DdManager * dd, int fTwice, int fVerbose )
-{
-    abctime clk = Abc_Clock();
-    if ( fVerbose )
-        Abc_Print( 1, "Reordering... Before =%5d. ", Cudd_ReadKeys(dd) - Cudd_ReadDead(dd) );
-    Cudd_ReduceHeap( dd, CUDD_REORDER_SYMM_SIFT, 100 );
-    if ( fVerbose )
-        Abc_Print( 1, "After =%5d. ", Cudd_ReadKeys(dd) - Cudd_ReadDead(dd) );
-    if ( fTwice )
-    {
-        Cudd_ReduceHeap( dd, CUDD_REORDER_SYMM_SIFT, 100 );
-        if ( fVerbose )
-            Abc_Print( 1, "After =%5d. ", Cudd_ReadKeys(dd) - Cudd_ReadDead(dd) );
-    }
-    if ( fVerbose )
-        Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Recomputes scores after variable reordering.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_NonlinRecomputeScores( Llb_Mgr_t * p )
-{
-    Llb_Prt_t * pPart;
-    Llb_Var_t * pVar;
-    int i, k;
-    Llb_MgrForEachPart( p, pPart, i )
-        pPart->nSize = Cudd_DagSize(pPart->bFunc);
-    Llb_MgrForEachVar( p, pVar, i )
-    {
-        pVar->nScore = 0;
-        Llb_VarForEachPart( p, pVar, pPart, k )
-            pVar->nScore += pPart->nSize;
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Recomputes scores after variable reordering.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_NonlinVerifyScores( Llb_Mgr_t * p )
-{
-    Llb_Prt_t * pPart;
-    Llb_Var_t * pVar;
-    int i, k, nScore;
-    Llb_MgrForEachPart( p, pPart, i )
-        assert( pPart->nSize == Cudd_DagSize(pPart->bFunc) );
-    Llb_MgrForEachVar( p, pVar, i )
-    {
-        nScore = 0;
-        Llb_VarForEachPart( p, pVar, pPart, k )
-            nScore += pPart->nSize;
-        assert( nScore == pVar->nScore );
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Starts non-linear quantification scheduling.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Llb_Mgr_t * Llb_NonlinAlloc( Aig_Man_t * pAig, Vec_Ptr_t * vLeaves, Vec_Ptr_t * vRoots, int * pVars2Q, DdManager * dd )
-{
-    Llb_Mgr_t * p;
-    p = ABC_CALLOC( Llb_Mgr_t, 1 );
-    p->pAig      = pAig;
-    p->vLeaves   = vLeaves;
-    p->vRoots    = vRoots;
-    p->dd        = dd;
-    p->pVars2Q   = pVars2Q;
-    p->nVars     = Cudd_ReadSize(dd);
-    p->iPartFree = Vec_PtrSize(vRoots);
-    p->pVars     = ABC_CALLOC( Llb_Var_t *, p->nVars );
-    p->pParts    = ABC_CALLOC( Llb_Prt_t *, 2 * p->iPartFree + 2 );
-    p->pSupp     = ABC_ALLOC( int, Cudd_ReadSize(dd) );
-    return p;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Stops non-linear quantification scheduling.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_NonlinFree( Llb_Mgr_t * p )
-{
-    Llb_Prt_t * pPart;
-    Llb_Var_t * pVar;
-    int i;
-    Llb_MgrForEachVar( p, pVar, i )
-        Llb_NonlinRemoveVar( p, pVar );
-    Llb_MgrForEachPart( p, pPart, i )
-        Llb_NonlinRemovePart( p, pPart );
-    ABC_FREE( p->pVars );
-    ABC_FREE( p->pParts );
-    ABC_FREE( p->pSupp );
-    ABC_FREE( p );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Performs image computation.]
-
-  Description [Computes image of BDDs (vFuncs).]
-               
-  SideEffects [BDDs in vFuncs are derefed inside. The result is refed.]
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb_NonlinImage( Aig_Man_t * pAig, Vec_Ptr_t * vLeaves, Vec_Ptr_t * vRoots, int * pVars2Q, 
-    DdManager * dd, DdNode * bCurrent, int fReorder, int fVerbose, int * pOrder )
-{
-    Llb_Prt_t * pPart, * pPart1, * pPart2;
-    Llb_Mgr_t * p;
-    DdNode * bFunc, * bTemp;
-    int i, nReorders, timeInside;
-    abctime clk = Abc_Clock(), clk2;
-    // start the manager
-    clk2 = Abc_Clock();
-    p = Llb_NonlinAlloc( pAig, vLeaves, vRoots, pVars2Q, dd );
-    if ( !Llb_NonlinStart( p ) )
-    {
-        Llb_NonlinFree( p );
-        return NULL;
-    }
-    // add partition
-    Llb_NonlinAddPartition( p, p->iPartFree++, bCurrent );
-    // remove singles
-    Llb_MgrForEachPart( p, pPart, i )
-        if ( Llb_NonlinHasSingletonVars(p, pPart) )
-            Llb_NonlinQuantify1( p, pPart, 0 );
-    timeBuild += Abc_Clock() - clk2;
-    timeInside = Abc_Clock() - clk2;
-    // compute scores
-    Llb_NonlinRecomputeScores( p );
-    // save permutation
-    if ( pOrder )
-    memcpy( pOrder, dd->invperm, sizeof(int) * dd->size );
-    // iteratively quantify variables
-    while ( Llb_NonlinNextPartitions(p, &pPart1, &pPart2) )
-    {
-        clk2 = Abc_Clock();
-        nReorders = Cudd_ReadReorderings(dd);
-        if ( !Llb_NonlinQuantify2( p, pPart1, pPart2 ) )
-        {
-            Llb_NonlinFree( p );
-            return NULL;
-        }
-        timeAndEx  += Abc_Clock() - clk2;
-        timeInside += Abc_Clock() - clk2;
-        if ( nReorders < Cudd_ReadReorderings(dd) )
-            Llb_NonlinRecomputeScores( p );
-//        else
-//            Llb_NonlinVerifyScores( p );
-    }
-    // load partitions
-    bFunc = Cudd_ReadOne(p->dd);   Cudd_Ref( bFunc );
-    Llb_MgrForEachPart( p, pPart, i )
-    {
-        bFunc = Cudd_bddAnd( p->dd, bTemp = bFunc, pPart->bFunc );   Cudd_Ref( bFunc );
-        Cudd_RecursiveDeref( p->dd, bTemp );
-    }
-    nSuppMax = p->nSuppMax;
-    Llb_NonlinFree( p );
-    // reorder variables
-    if ( fReorder )
-        Llb_NonlinReorder( dd, 0, fVerbose );
-    timeOther += Abc_Clock() - clk - timeInside;
-    // return
-    Cudd_Deref( bFunc );
-    return bFunc;
-}
-
-
-
-static Llb_Mgr_t * p = NULL;
-
-/**Function*************************************************************
-
-  Synopsis    [Starts image computation manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdManager * Llb_NonlinImageStart( Aig_Man_t * pAig, Vec_Ptr_t * vLeaves, Vec_Ptr_t * vRoots, int * pVars2Q, int * pOrder, int fFirst, abctime TimeTarget )
-{
-    DdManager * dd;
-    abctime clk = Abc_Clock();
-    assert( p == NULL );
-    // start a new manager (disable reordering)
-    dd = Cudd_Init( Aig_ManObjNumMax(pAig), 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
-    dd->TimeStop = TimeTarget;
-    Cudd_ShuffleHeap( dd, pOrder );
-//    if ( fFirst )
-        Cudd_AutodynEnable( dd,  CUDD_REORDER_SYMM_SIFT );
-    // start the manager
-    p = Llb_NonlinAlloc( pAig, vLeaves, vRoots, pVars2Q, dd );
-    if ( !Llb_NonlinStart( p ) )
-    {
-        Llb_NonlinFree( p );
-        p = NULL;
-        return NULL;
-    }
-    timeBuild += Abc_Clock() - clk;
-//    if ( !fFirst )
-//        Cudd_AutodynEnable( dd,  CUDD_REORDER_SYMM_SIFT );
-    return dd;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Performs image computation.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb_NonlinImageCompute( DdNode * bCurrent, int fReorder, int fDrop, int fVerbose, int * pOrder )
-{
-    Llb_Prt_t * pPart, * pPart1, * pPart2;
-    DdNode * bFunc, * bTemp;
-    int i, nReorders, timeInside = 0;
-    abctime clk = Abc_Clock(), clk2;
-
-    // add partition
-    Llb_NonlinAddPartition( p, p->iPartFree++, bCurrent );
-    // remove singles
-    Llb_MgrForEachPart( p, pPart, i )
-        if ( Llb_NonlinHasSingletonVars(p, pPart) )
-            Llb_NonlinQuantify1( p, pPart, 0 );
-    // reorder
-    if ( fReorder )
-        Llb_NonlinReorder( p->dd, 0, 0 );
-    // save permutation
-    memcpy( pOrder, p->dd->invperm, sizeof(int) * p->dd->size );
-
-    // compute scores
-    Llb_NonlinRecomputeScores( p );
-    // iteratively quantify variables
-    while ( Llb_NonlinNextPartitions(p, &pPart1, &pPart2) )
-    {
-        clk2 = Abc_Clock();
-        nReorders = Cudd_ReadReorderings(p->dd);
-        if ( !Llb_NonlinQuantify2( p, pPart1, pPart2 ) )
-        {
-            Llb_NonlinFree( p );
-            return NULL;
-        }
-        timeAndEx  += Abc_Clock() - clk2;
-        timeInside += Abc_Clock() - clk2;
-        if ( nReorders < Cudd_ReadReorderings(p->dd) )
-            Llb_NonlinRecomputeScores( p );
-//        else
-//            Llb_NonlinVerifyScores( p );
-    }
-    // load partitions
-    bFunc = Cudd_ReadOne(p->dd);   Cudd_Ref( bFunc );
-    Llb_MgrForEachPart( p, pPart, i )
-    {
-        bFunc = Cudd_bddAnd( p->dd, bTemp = bFunc, pPart->bFunc );
-        if ( bFunc == NULL )
-        {
-            Cudd_RecursiveDeref( p->dd, bTemp );
-            Llb_NonlinFree( p );
-            return NULL;
-        }
-        Cudd_Ref( bFunc );
-        Cudd_RecursiveDeref( p->dd, bTemp );
-    }
-    nSuppMax = p->nSuppMax;
-    // reorder variables
-//    if ( fReorder )
-//        Llb_NonlinReorder( p->dd, 0, fVerbose );
-    // save permutation
-//    memcpy( pOrder, p->dd->invperm, sizeof(int) * Cudd_ReadSize(p->dd) );
-
-    timeOther += Abc_Clock() - clk - timeInside;
-    // return
-    Cudd_Deref( bFunc );
-    return bFunc;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Quits image computation manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_NonlinImageQuit()
-{
-    DdManager * dd;
-    if ( p == NULL )
-        return;
-    dd = p->dd;
-    Llb_NonlinFree( p );
-    if ( dd->bFunc )
-        Cudd_RecursiveDeref( dd, dd->bFunc );
-    Extra_StopManager( dd );
-//    Cudd_Quit ( dd );
-    p = NULL;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/llb/llb3Nonlin.c b/src/proof/llb/llb3Nonlin.c
deleted file mode 100644
index 94a48bbf..00000000
--- a/src/proof/llb/llb3Nonlin.c
+++ /dev/null
@@ -1,872 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [llb2Nonlin.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD based reachability.]
-
-  Synopsis    [Non-linear quantification scheduling.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: llb2Nonlin.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "llbInt.h"
-
-ABC_NAMESPACE_IMPL_START
- 
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-typedef struct Llb_Mnn_t_ Llb_Mnn_t;
-struct Llb_Mnn_t_
-{
-    Aig_Man_t *     pInit;          // AIG manager
-    Aig_Man_t *     pAig;           // AIG manager
-    Gia_ParLlb_t *  pPars;          // parameters
-
-    DdManager *     dd;             // BDD manager
-    DdManager *     ddG;            // BDD manager
-    DdManager *     ddR;            // BDD manager
-    Vec_Ptr_t *     vRings;         // onion rings in ddR
-
-    Vec_Ptr_t *     vLeaves;        
-    Vec_Ptr_t *     vRoots;
-    int *           pVars2Q;
-    int *           pOrderL;
-    int *           pOrderL2;
-    int *           pOrderG;
-
-    Vec_Int_t *     vCs2Glo;        // cur state variables into global variables
-    Vec_Int_t *     vNs2Glo;        // next state variables into global variables
-    Vec_Int_t *     vGlo2Cs;        // global variables into cur state variables
-    Vec_Int_t *     vGlo2Ns;        // global variables into next state variables
-
-    int             ddLocReos;
-    int             ddLocGrbs;
-
-    abctime         timeImage;
-    abctime         timeTran1;
-    abctime         timeTran2;
-    abctime         timeGloba;
-    abctime         timeOther;
-    abctime         timeTotal;
-    abctime         timeReo;
-    abctime         timeReoG;
-
-};
-
-extern abctime timeBuild, timeAndEx, timeOther;
-extern int nSuppMax;
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Finds variable whose 0-cofactor is the smallest.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_NonlinFindBestVar( DdManager * dd, DdNode * bFunc, Aig_Man_t * pAig )
-{
-    int fVerbose = 0;
-    Aig_Obj_t * pObj;
-    DdNode * bCof, * bVar;
-    int i, iVar, iVarBest = -1, iValue, iValueBest = ABC_INFINITY, Size0Best = -1;
-    int Size, Size0, Size1;
-    abctime clk = Abc_Clock();
-    Size = Cudd_DagSize(bFunc);
-//    printf( "Original = %6d.  SuppSize = %3d. Vars = %3d.\n", 
-//        Size = Cudd_DagSize(bFunc), Cudd_SupportSize(dd, bFunc), Aig_ManRegNum(pAig) );
-    Saig_ManForEachLo( pAig, pObj, i )
-    {
-        iVar = Aig_ObjId(pObj);
-
-if ( fVerbose )
-printf( "Var =%3d : ", iVar );
-        bVar = Cudd_bddIthVar(dd, iVar);
-
-        bCof = Cudd_bddAnd( dd, bFunc, Cudd_Not(bVar) );          Cudd_Ref( bCof );
-        Size0 = Cudd_DagSize(bCof);
-if ( fVerbose )
-printf( "Supp0 =%3d  ",  Cudd_SupportSize(dd, bCof) );
-if ( fVerbose )
-printf( "Size0 =%6d   ", Size0 );
-        Cudd_RecursiveDeref( dd, bCof );
-
-        bCof = Cudd_bddAnd( dd, bFunc, bVar );                    Cudd_Ref( bCof );
-        Size1 = Cudd_DagSize(bCof);
-if ( fVerbose )
-printf( "Supp1 =%3d  ",  Cudd_SupportSize(dd, bCof) );
-if ( fVerbose )
-printf( "Size1 =%6d   ", Size1 );
-        Cudd_RecursiveDeref( dd, bCof );
-
-        iValue = Abc_MaxInt(Size0, Size1) - Abc_MinInt(Size0, Size1) + Size0 + Size1 - Size;
-if ( fVerbose )
-printf( "D =%6d  ", Size0 + Size1 - Size );
-if ( fVerbose )
-printf( "B =%6d  ", Abc_MaxInt(Size0, Size1) - Abc_MinInt(Size0, Size1) );
-if ( fVerbose )
-printf( "S =%6d\n", iValue );
-        if ( Size0 > 1 && Size1 > 1 && iValueBest > iValue )
-        {
-            iValueBest = iValue;
-            iVarBest   = i;
-            Size0Best  = Size0;
-        }
-    }
-    printf( "BestVar = %4d/%4d.  Value =%6d.  Orig =%6d. Size0 =%6d. ", 
-        iVarBest, Aig_ObjId(Saig_ManLo(pAig,iVarBest)), iValueBest, Size, Size0Best );
-    Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
-    return iVarBest;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Finds variable whose 0-cofactor is the smallest.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_NonlinTrySubsetting( DdManager * dd, DdNode * bFunc )
-{
-    DdNode * bNew;
-    printf( "Original = %6d.  SuppSize = %3d.    ", 
-        Cudd_DagSize(bFunc), Cudd_SupportSize(dd, bFunc) );
-    bNew = Cudd_SubsetHeavyBranch( dd, bFunc, Cudd_SupportSize(dd, bFunc), 1000 );  Cudd_Ref( bNew );
-    printf( "Result   = %6d.  SuppSize = %3d.\n", 
-        Cudd_DagSize(bNew), Cudd_SupportSize(dd, bNew) );
-    Cudd_RecursiveDeref( dd, bNew );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_NonlinPrepareVarMap( Llb_Mnn_t * p )
-{
-    Aig_Obj_t * pObjLi, * pObjLo, * pObj;
-    int i, iVarLi, iVarLo;
-    p->vCs2Glo = Vec_IntStartFull( Aig_ManObjNumMax(p->pAig) );
-    p->vNs2Glo = Vec_IntStartFull( Aig_ManObjNumMax(p->pAig) );
-    p->vGlo2Cs = Vec_IntStartFull( Aig_ManRegNum(p->pAig) );
-    p->vGlo2Ns = Vec_IntStartFull( Aig_ManRegNum(p->pAig) );
-    Saig_ManForEachLiLo( p->pAig, pObjLi, pObjLo, i )
-    {
-        iVarLi = Aig_ObjId(pObjLi);
-        iVarLo = Aig_ObjId(pObjLo);
-        assert( iVarLi >= 0 && iVarLi < Aig_ManObjNumMax(p->pAig) );
-        assert( iVarLo >= 0 && iVarLo < Aig_ManObjNumMax(p->pAig) );
-        Vec_IntWriteEntry( p->vCs2Glo, iVarLo, i );
-        Vec_IntWriteEntry( p->vNs2Glo, iVarLi, i );
-        Vec_IntWriteEntry( p->vGlo2Cs, i, iVarLo );
-        Vec_IntWriteEntry( p->vGlo2Ns, i, iVarLi );
-    }
-    // add mapping of the PIs
-    Saig_ManForEachPi( p->pAig, pObj, i )
-    {
-        Vec_IntWriteEntry( p->vCs2Glo, Aig_ObjId(pObj), Aig_ManRegNum(p->pAig)+i );
-        Vec_IntWriteEntry( p->vNs2Glo, Aig_ObjId(pObj), Aig_ManRegNum(p->pAig)+i );
-    }
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb_NonlinComputeInitState( Aig_Man_t * pAig, DdManager * dd )
-{
-    Aig_Obj_t * pObj;
-    DdNode * bRes, * bVar, * bTemp;
-    int i, iVar;
-    abctime TimeStop;
-    TimeStop = dd->TimeStop;  dd->TimeStop = 0;
-    bRes = Cudd_ReadOne( dd );   Cudd_Ref( bRes );
-    Saig_ManForEachLo( pAig, pObj, i )
-    {
-        iVar = (Cudd_ReadSize(dd) == Aig_ManRegNum(pAig)) ? i : Aig_ObjId(pObj);
-        bVar = Cudd_bddIthVar( dd, iVar );
-        bRes = Cudd_bddAnd( dd, bTemp = bRes, Cudd_Not(bVar) );  Cudd_Ref( bRes );
-        Cudd_RecursiveDeref( dd, bTemp );
-    }
-    Cudd_Deref( bRes );
-    dd->TimeStop = TimeStop;
-    return bRes;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Derives counter-example by backward reachability.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Abc_Cex_t * Llb_NonlinDeriveCex( Llb_Mnn_t * p )
-{
-    Abc_Cex_t * pCex;
-    Aig_Obj_t * pObj;
-    Vec_Int_t * vVarsNs;
-    DdNode * bState = NULL, * bImage, * bOneCube, * bTemp, * bRing;
-    int i, v, RetValue, nPiOffset;
-    char * pValues = ABC_ALLOC( char, Cudd_ReadSize(p->ddR) );
-    assert( Vec_PtrSize(p->vRings) > 0 );
-
-    p->dd->TimeStop  = 0;
-    p->ddR->TimeStop = 0;
-
-    // update quantifiable vars
-    memset( p->pVars2Q, 0, sizeof(int) * Cudd_ReadSize(p->dd) );
-    vVarsNs = Vec_IntAlloc( Aig_ManRegNum(p->pAig) );
-    Saig_ManForEachLi( p->pAig, pObj, i )
-    {
-        p->pVars2Q[Aig_ObjId(pObj)] = 1;
-        Vec_IntPush( vVarsNs, Aig_ObjId(pObj) );
-    }
-/*
-    Saig_ManForEachLo( p->pAig, pObj, i )
-        printf( "%d ", pObj->Id );
-    printf( "\n" );
-    Saig_ManForEachLi( p->pAig, pObj, i )
-        printf( "%d(%d) ", pObj->Id, Aig_ObjFaninId0(pObj) );
-    printf( "\n" );
-*/
-    // allocate room for the counter-example
-    pCex = Abc_CexAlloc( Saig_ManRegNum(p->pAig), Saig_ManPiNum(p->pAig), Vec_PtrSize(p->vRings) );
-    pCex->iFrame = Vec_PtrSize(p->vRings) - 1;
-    pCex->iPo = -1;
-
-    // get the last cube
-    bOneCube = Cudd_bddIntersect( p->ddR, (DdNode *)Vec_PtrEntryLast(p->vRings), p->ddR->bFunc );  Cudd_Ref( bOneCube );
-    RetValue = Cudd_bddPickOneCube( p->ddR, bOneCube, pValues );
-    Cudd_RecursiveDeref( p->ddR, bOneCube );
-    assert( RetValue );
-
-    // write PIs of counter-example
-    nPiOffset = Saig_ManRegNum(p->pAig) + Saig_ManPiNum(p->pAig) * (Vec_PtrSize(p->vRings) - 1);
-    Saig_ManForEachPi( p->pAig, pObj, i )
-        if ( pValues[Saig_ManRegNum(p->pAig)+i] == 1 )
-            Abc_InfoSetBit( pCex->pData, nPiOffset + i );
-
-    // write state in terms of NS variables
-    if ( Vec_PtrSize(p->vRings) > 1 )
-    {
-        bState = Llb_CoreComputeCube( p->dd, vVarsNs, 1, pValues );   Cudd_Ref( bState );
-    }
-    // perform backward analysis
-    Vec_PtrForEachEntryReverse( DdNode *, p->vRings, bRing, v )
-    { 
-        if ( v == Vec_PtrSize(p->vRings) - 1 )
-            continue;
-//Extra_bddPrintSupport( p->dd, bState );  printf( "\n" );
-//Extra_bddPrintSupport( p->dd, bRing );   printf( "\n" );
-        // compute the next states
-        bImage = Llb_NonlinImage( p->pAig, p->vLeaves, p->vRoots, p->pVars2Q, p->dd, bState, 
-            p->pPars->fReorder, p->pPars->fVeryVerbose, NULL ); // consumed reference
-        assert( bImage != NULL );
-        Cudd_Ref( bImage );
-//Extra_bddPrintSupport( p->dd, bImage );  printf( "\n" );
-
-        // move reached states into ring manager
-        bImage = Extra_TransferPermute( p->dd, p->ddR, bTemp = bImage, Vec_IntArray(p->vCs2Glo) );    Cudd_Ref( bImage );
-        Cudd_RecursiveDeref( p->dd, bTemp );
-
-        // intersect with the previous set
-        bOneCube = Cudd_bddIntersect( p->ddR, bImage, bRing );                Cudd_Ref( bOneCube );
-        Cudd_RecursiveDeref( p->ddR, bImage );
-
-        // find any assignment of the BDD
-        RetValue = Cudd_bddPickOneCube( p->ddR, bOneCube, pValues );
-        Cudd_RecursiveDeref( p->ddR, bOneCube );
-        assert( RetValue );
-
-        // write PIs of counter-example
-        nPiOffset -= Saig_ManPiNum(p->pAig);
-        Saig_ManForEachPi( p->pAig, pObj, i )
-            if ( pValues[Saig_ManRegNum(p->pAig)+i] == 1 )
-                Abc_InfoSetBit( pCex->pData, nPiOffset + i );
-
-        // check that we get the init state
-        if ( v == 0 )
-        {
-            Saig_ManForEachLo( p->pAig, pObj, i )
-                assert( pValues[i] == 0 );
-            break;
-        }
-
-        // write state in terms of NS variables
-        bState = Llb_CoreComputeCube( p->dd, vVarsNs, 1, pValues );   Cudd_Ref( bState );
-    }
-    assert( nPiOffset == Saig_ManRegNum(p->pAig) );
-    // update the output number
-//Abc_CexPrint( pCex );
-    RetValue = Saig_ManFindFailedPoCex( p->pInit, pCex );
-    assert( RetValue >= 0 && RetValue < Saig_ManPoNum(p->pInit) ); // invalid CEX!!!
-    pCex->iPo = RetValue;
-    // cleanup
-    ABC_FREE( pValues );
-    Vec_IntFree( vVarsNs );
-    return pCex;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Perform reachability with hints.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_NonlinReoHook( DdManager * dd, char * Type, void * Method )
-{
-    Aig_Man_t * pAig = (Aig_Man_t *)dd->bFunc;
-    Aig_Obj_t * pObj;
-    int i;
-    printf( "Order: " );
-    for ( i = 0; i < Cudd_ReadSize(dd); i++ )
-    {
-        pObj = Aig_ManObj( pAig, i );
-        if ( pObj == NULL )
-            continue;
-        if ( Saig_ObjIsPi(pAig, pObj) )
-            printf( "pi" );
-        else if ( Saig_ObjIsLo(pAig, pObj) )
-            printf( "lo" );
-        else if ( Saig_ObjIsPo(pAig, pObj) )
-            printf( "po" );
-        else if ( Saig_ObjIsLi(pAig, pObj) )
-            printf( "li" );
-        else continue;
-        printf( "%d=%d ", i, dd->perm[i] );
-    }
-    printf( "\n" );
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Perform reachability with hints.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_NonlinCompPerms( DdManager * dd, int * pVar2Lev )
-{
-    DdSubtable * pSubt;
-    int i, Sum = 0, Entry;
-    for ( i = 0; i < dd->size; i++ )
-    {
-        pSubt = &(dd->subtables[dd->perm[i]]);
-        if ( pSubt->keys == pSubt->dead + 1 )
-            continue;
-        Entry = Abc_MaxInt(dd->perm[i], pVar2Lev[i]) - Abc_MinInt(dd->perm[i], pVar2Lev[i]);
-        Sum += Entry;
-//printf( "%d-%d(%d) ", dd->perm[i], pV2L[i], Entry );
-    }
-    return Sum;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Perform reachability with hints.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_NonlinReachability( Llb_Mnn_t * p )
-{ 
-    DdNode * bTemp, * bNext;
-    int nIters, nBddSize0, nBddSize = -1, NumCmp;//, Limit = p->pPars->nBddMax;
-    abctime clk2, clk3, clk = Abc_Clock();
-    assert( Aig_ManRegNum(p->pAig) > 0 );
-
-    // compute time to stop
-    p->pPars->TimeTarget = p->pPars->TimeLimit ? p->pPars->TimeLimit * CLOCKS_PER_SEC + Abc_Clock(): 0;
-
-    // set the stop time parameter
-    p->dd->TimeStop  = p->pPars->TimeTarget;
-    p->ddG->TimeStop = p->pPars->TimeTarget;
-    p->ddR->TimeStop = p->pPars->TimeTarget;
-
-    // set reordering hooks
-    assert( p->dd->bFunc == NULL );
-//    p->dd->bFunc = (DdNode *)p->pAig;
-//    Cudd_AddHook( p->dd, Llb_NonlinReoHook, CUDD_POST_REORDERING_HOOK );
-
-    // create bad state in the ring manager
-    p->ddR->bFunc  = Llb_BddComputeBad( p->pInit, p->ddR, p->pPars->TimeTarget );          
-    if ( p->ddR->bFunc == NULL )
-    {
-        if ( !p->pPars->fSilent )
-            printf( "Reached timeout (%d seconds) during constructing the bad states.\n", p->pPars->TimeLimit );
-        p->pPars->iFrame = -1;
-        return -1;
-    }
-    Cudd_Ref( p->ddR->bFunc );
-    // compute the starting set of states
-    Cudd_Quit( p->dd );
-    p->dd = Llb_NonlinImageStart( p->pAig, p->vLeaves, p->vRoots, p->pVars2Q, p->pOrderL, 1, p->pPars->TimeTarget );
-    if ( p->dd == NULL )
-    {
-        if ( !p->pPars->fSilent )
-            printf( "Reached timeout (%d seconds) during constructing the bad states.\n", p->pPars->TimeLimit );
-        p->pPars->iFrame = -1;
-        return -1;
-    }
-    p->dd->bFunc   = Llb_NonlinComputeInitState( p->pAig, p->dd );   Cudd_Ref( p->dd->bFunc );   // current
-    p->ddG->bFunc  = Llb_NonlinComputeInitState( p->pAig, p->ddG );  Cudd_Ref( p->ddG->bFunc );  // reached
-    p->ddG->bFunc2 = Llb_NonlinComputeInitState( p->pAig, p->ddG );  Cudd_Ref( p->ddG->bFunc2 ); // frontier 
-    for ( nIters = 0; nIters < p->pPars->nIterMax; nIters++ )
-    { 
-        // check the runtime limit
-        clk2 = Abc_Clock();
-        if ( p->pPars->TimeLimit && Abc_Clock() > p->pPars->TimeTarget )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached timeout (%d seconds) during image computation.\n",  p->pPars->TimeLimit );
-            p->pPars->iFrame = nIters - 1;
-            Llb_NonlinImageQuit();
-            return -1;
-        }
-
-        // save the onion ring
-        bTemp = Extra_TransferPermute( p->dd, p->ddR, p->dd->bFunc, Vec_IntArray(p->vCs2Glo) );
-        if ( bTemp == NULL )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached timeout (%d seconds) during ring transfer.\n",  p->pPars->TimeLimit );
-            p->pPars->iFrame = nIters - 1;
-            Llb_NonlinImageQuit();
-            return -1;
-        }
-        Cudd_Ref( bTemp );
-        Vec_PtrPush( p->vRings, bTemp );
-
-        // check it for bad states
-        if ( !p->pPars->fSkipOutCheck && !Cudd_bddLeq( p->ddR, bTemp, Cudd_Not(p->ddR->bFunc) ) ) 
-        {
-            assert( p->pInit->pSeqModel == NULL );
-            if ( !p->pPars->fBackward )
-                p->pInit->pSeqModel = Llb_NonlinDeriveCex( p ); 
-            if ( !p->pPars->fSilent )
-            {
-                if ( !p->pPars->fBackward )
-                    Abc_Print( 1, "Output %d of miter \"%s\" was asserted in frame %d.  ", p->pInit->pSeqModel->iPo, nIters );
-                else
-                    Abc_Print( 1, "Output ??? was asserted in frame %d (counter-example is not produced).  ", nIters );
-                Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
-            }
-            p->pPars->iFrame = nIters - 1;
-            Llb_NonlinImageQuit();
-            return 0;
-        }
-
-        // compute the next states
-        clk3 = Abc_Clock();
-        nBddSize0 = Cudd_DagSize( p->dd->bFunc );
-        bNext = Llb_NonlinImageCompute( p->dd->bFunc, p->pPars->fReorder, 0, 1, p->pOrderL ); // consumes ref   
-//        bNext = Llb_NonlinImage( p->pAig, p->vLeaves, p->vRoots, p->pVars2Q, p->dd, bCurrent, 
-//            p->pPars->fReorder, p->pPars->fVeryVerbose, NULL, ABC_INFINITY, p->pPars->TimeTarget );
-        if ( bNext == NULL )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached timeout (%d seconds) during image computation in quantification.\n",  p->pPars->TimeLimit );
-            p->pPars->iFrame = nIters - 1;
-            Llb_NonlinImageQuit();
-            return -1;
-        }
-        Cudd_Ref( bNext );
-        nBddSize = Cudd_DagSize( bNext );
-        p->timeImage += Abc_Clock() - clk3;
-
-
-        // transfer to the state manager
-        clk3 = Abc_Clock();
-        Cudd_RecursiveDeref( p->ddG, p->ddG->bFunc2 );
-        p->ddG->bFunc2 = Extra_TransferPermute( p->dd, p->ddG, bNext, Vec_IntArray(p->vNs2Glo) );    
-//        p->ddG->bFunc2 = Extra_bddAndPermute( p->ddG, Cudd_Not(p->ddG->bFunc), p->dd, bNext, Vec_IntArray(p->vNs2Glo) );    
-        if ( p->ddG->bFunc2 == NULL )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached timeout (%d seconds) during image computation in transfer 1.\n",  p->pPars->TimeLimit );
-            p->pPars->iFrame = nIters - 1;
-            Cudd_RecursiveDeref( p->dd,  bNext );  
-            Llb_NonlinImageQuit();
-            return -1;
-        }
-        Cudd_Ref( p->ddG->bFunc2 );
-        Cudd_RecursiveDeref( p->dd, bNext );
-        p->timeTran1 += Abc_Clock() - clk3;
-
-        // save permutation
-        NumCmp = Llb_NonlinCompPerms( p->dd, p->pOrderL2 );
-        // save order before image computation
-        memcpy( p->pOrderL2, p->dd->perm, sizeof(int) * p->dd->size );
-        // update the image computation manager
-        p->timeReo   += Cudd_ReadReorderingTime(p->dd);
-        p->ddLocReos += Cudd_ReadReorderings(p->dd);
-        p->ddLocGrbs += Cudd_ReadGarbageCollections(p->dd);
-        Llb_NonlinImageQuit();
-        p->dd = Llb_NonlinImageStart( p->pAig, p->vLeaves, p->vRoots, p->pVars2Q, p->pOrderL, 0, p->pPars->TimeTarget );
-        if ( p->dd == NULL )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached timeout (%d seconds) during constructing the bad states.\n", p->pPars->TimeLimit );
-            p->pPars->iFrame = nIters - 1;
-            return -1;
-        }
-        //Extra_TestAndPerm( p->ddG, Cudd_Not(p->ddG->bFunc), p->ddG->bFunc2 );    
-
-        // derive new states
-        clk3 = Abc_Clock();
-        p->ddG->bFunc2 = Cudd_bddAnd( p->ddG, bTemp = p->ddG->bFunc2, Cudd_Not(p->ddG->bFunc) );     
-        if ( p->ddG->bFunc2 == NULL )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached timeout (%d seconds) during image computation in transfer 1.\n",  p->pPars->TimeLimit );
-            p->pPars->iFrame = nIters - 1;
-            Cudd_RecursiveDeref( p->ddG, bTemp );  
-            Llb_NonlinImageQuit();
-            return -1;
-        }
-        Cudd_Ref( p->ddG->bFunc2 );
-        Cudd_RecursiveDeref( p->ddG, bTemp );
-        p->timeGloba += Abc_Clock() - clk3;
-
-        if ( Cudd_IsConstant(p->ddG->bFunc2) )
-            break;
-        // add to the reached set
-        clk3 = Abc_Clock();
-        p->ddG->bFunc = Cudd_bddOr( p->ddG, bTemp = p->ddG->bFunc, p->ddG->bFunc2 );                 
-        if ( p->ddG->bFunc == NULL )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached timeout (%d seconds) during image computation in transfer 1.\n",  p->pPars->TimeLimit );
-            p->pPars->iFrame = nIters - 1;
-            Cudd_RecursiveDeref( p->ddG, bTemp );  
-            Llb_NonlinImageQuit();
-            return -1;
-        }
-        Cudd_Ref( p->ddG->bFunc );
-        Cudd_RecursiveDeref( p->ddG, bTemp );
-        p->timeGloba += Abc_Clock() - clk3;
-
-        // reset permutation
-//        RetValue = Cudd_CheckZeroRef( dd );
-//        assert( RetValue == 0 );
-//        Cudd_ShuffleHeap( dd, pOrderG );
-
-        // move new states to the working manager
-        clk3 = Abc_Clock();
-        p->dd->bFunc = Extra_TransferPermute( p->ddG, p->dd, p->ddG->bFunc2, Vec_IntArray(p->vGlo2Cs) ); 
-        if ( p->dd->bFunc == NULL )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached timeout (%d seconds) during image computation in transfer 2.\n",  p->pPars->TimeLimit );
-            p->pPars->iFrame = nIters - 1;
-            Llb_NonlinImageQuit();
-            return -1;
-        }
-        Cudd_Ref( p->dd->bFunc );
-        p->timeTran2 += Abc_Clock() - clk3;
-
-        // report the results
-        if ( p->pPars->fVerbose )
-        {
-            printf( "I =%3d : ",   nIters );
-            printf( "Fr =%7d ",    nBddSize0 );
-            printf( "Im =%7d  ",   nBddSize );
-            printf( "(%4d %4d)  ", p->ddLocReos, p->ddLocGrbs );
-            printf( "Rea =%6d  ",  Cudd_DagSize(p->ddG->bFunc) );
-            printf( "(%4d %4d)  ", Cudd_ReadReorderings(p->ddG), Cudd_ReadGarbageCollections(p->ddG) );
-            printf( "S =%4d ",     nSuppMax );
-            printf( "cL =%5d ",    NumCmp );
-            printf( "cG =%5d ",    Llb_NonlinCompPerms( p->ddG, p->pOrderG ) );
-            Abc_PrintTime( 1, "T", Abc_Clock() - clk2 );
-            memcpy( p->pOrderG, p->ddG->perm, sizeof(int) * p->ddG->size );
-        }
-/*
-        if ( pPars->fVerbose )
-        {
-            double nMints = Cudd_CountMinterm(ddG, bReached, Saig_ManRegNum(pAig) );
-//            Extra_bddPrint( ddG, bReached );printf( "\n" );
-            printf( "Reachable states = %.0f. (Ratio = %.4f %%)\n", nMints, 100.0*nMints/pow(2.0, Saig_ManRegNum(pAig)) );
-            fflush( stdout ); 
-        }
-*/
-        if ( nIters == p->pPars->nIterMax - 1 )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached limit on the number of timeframes (%d).\n",  p->pPars->nIterMax );
-            p->pPars->iFrame = nIters;
-            Llb_NonlinImageQuit();
-            return -1;
-        }
-    }
-    Llb_NonlinImageQuit();
-    
-    // report the stats
-    if ( p->pPars->fVerbose )
-    {
-        double nMints = Cudd_CountMinterm(p->ddG, p->ddG->bFunc, Saig_ManRegNum(p->pAig) );
-        if ( nIters >= p->pPars->nIterMax || nBddSize > p->pPars->nBddMax )
-            printf( "Reachability analysis is stopped after %d frames.\n", nIters );
-        else
-            printf( "Reachability analysis completed after %d frames.\n", nIters );
-        printf( "Reachable states = %.0f. (Ratio = %.4f %%)\n", nMints, 100.0*nMints/pow(2.0, Saig_ManRegNum(p->pAig)) );
-        fflush( stdout ); 
-    }
-    if ( nIters >= p->pPars->nIterMax || nBddSize > p->pPars->nBddMax )
-    {
-        if ( !p->pPars->fSilent )
-            printf( "Verified only for states reachable in %d frames.  ", nIters );
-        p->pPars->iFrame = p->pPars->nIterMax;
-        return -1; // undecided
-    }
-    // report
-    if ( !p->pPars->fSilent )
-        printf( "The miter is proved unreachable after %d iterations.  ", nIters );
-    p->pPars->iFrame = nIters - 1;
-    Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
-    return 1; // unreachable
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Llb_Mnn_t * Llb_MnnStart( Aig_Man_t * pInit, Aig_Man_t * pAig, Gia_ParLlb_t *  pPars )
-{
-    Llb_Mnn_t * p;
-    Aig_Obj_t * pObj;
-    int i;
-    p = ABC_CALLOC( Llb_Mnn_t, 1 );
-    p->pInit = pInit;
-    p->pAig  = pAig;
-    p->pPars = pPars;
-    p->dd    = Cudd_Init( Aig_ManObjNumMax(pAig), 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
-    p->ddG   = Cudd_Init( Aig_ManRegNum(pAig),    0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
-    p->ddR   = Cudd_Init( Aig_ManCiNum(pAig),     0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
-    Cudd_AutodynEnable( p->dd,  CUDD_REORDER_SYMM_SIFT );
-    Cudd_AutodynEnable( p->ddG, CUDD_REORDER_SYMM_SIFT );
-    Cudd_AutodynEnable( p->ddR, CUDD_REORDER_SYMM_SIFT );
-    p->vRings = Vec_PtrAlloc( 100 );
-    // create leaves
-    p->vLeaves = Vec_PtrAlloc( Aig_ManCiNum(pAig) );
-    Aig_ManForEachCi( pAig, pObj, i )
-        Vec_PtrPush( p->vLeaves, pObj );
-    // create roots
-    p->vRoots = Vec_PtrAlloc( Aig_ManCoNum(pAig) );
-    Saig_ManForEachLi( pAig, pObj, i )
-        Vec_PtrPush( p->vRoots, pObj );
-    // variables to quantify
-    p->pOrderL = ABC_CALLOC( int, Aig_ManObjNumMax(pAig) );
-    p->pOrderL2= ABC_CALLOC( int, Aig_ManObjNumMax(pAig) );
-    p->pOrderG = ABC_CALLOC( int, Aig_ManObjNumMax(pAig) );
-    p->pVars2Q = ABC_CALLOC( int, Aig_ManObjNumMax(pAig) );
-    Aig_ManForEachCi( pAig, pObj, i )
-        p->pVars2Q[Aig_ObjId(pObj)] = 1;
-    for ( i = 0; i < Aig_ManObjNumMax(pAig); i++ )
-        p->pOrderL[i] = p->pOrderL2[i] = p->pOrderG[i] = i;
-    Llb_NonlinPrepareVarMap( p ); 
-    return p;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_MnnStop( Llb_Mnn_t * p )
-{
-    DdNode * bTemp;
-    int i;
-    if ( p->pPars->fVerbose ) 
-    {
-        p->timeOther = p->timeTotal - p->timeImage - p->timeTran1 - p->timeTran2 - p->timeGloba;
-        p->timeReoG  = Cudd_ReadReorderingTime(p->ddG);
-        ABC_PRTP( "Image    ", p->timeImage, p->timeTotal );
-        ABC_PRTP( "  build  ",    timeBuild, p->timeTotal );
-        ABC_PRTP( "  and-ex ",    timeAndEx, p->timeTotal );
-        ABC_PRTP( "  other  ",    timeOther, p->timeTotal );
-        ABC_PRTP( "Transfer1", p->timeTran1, p->timeTotal );
-        ABC_PRTP( "Transfer2", p->timeTran2, p->timeTotal );
-        ABC_PRTP( "Global   ", p->timeGloba, p->timeTotal );
-        ABC_PRTP( "Other    ", p->timeOther, p->timeTotal );
-        ABC_PRTP( "TOTAL    ", p->timeTotal, p->timeTotal );
-        ABC_PRTP( "  reo    ", p->timeReo,   p->timeTotal );
-        ABC_PRTP( "  reoG   ", p->timeReoG,  p->timeTotal );
-    }
-    if ( p->ddR->bFunc )
-        Cudd_RecursiveDeref( p->ddR, p->ddR->bFunc );
-    Vec_PtrForEachEntry( DdNode *, p->vRings, bTemp, i )
-        Cudd_RecursiveDeref( p->ddR, bTemp );
-    Vec_PtrFree( p->vRings );
-    if ( p->ddG->bFunc )
-        Cudd_RecursiveDeref( p->ddG, p->ddG->bFunc );
-    if ( p->ddG->bFunc2 )
-        Cudd_RecursiveDeref( p->ddG, p->ddG->bFunc2 );
-//    printf( "manager1\n" );
-//    Extra_StopManager( p->dd );
-//    printf( "manager2\n" );
-    Extra_StopManager( p->ddG );
-//    printf( "manager3\n" );
-    Extra_StopManager( p->ddR );
-    Vec_IntFreeP( &p->vCs2Glo );
-    Vec_IntFreeP( &p->vNs2Glo );
-    Vec_IntFreeP( &p->vGlo2Cs );
-    Vec_IntFreeP( &p->vGlo2Ns );
-    Vec_PtrFree( p->vLeaves );
-    Vec_PtrFree( p->vRoots );
-    ABC_FREE( p->pVars2Q );
-    ABC_FREE( p->pOrderL );
-    ABC_FREE( p->pOrderL2 );
-    ABC_FREE( p->pOrderG );
-    ABC_FREE( p );
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Finds balanced cut.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_NonlinExperiment( Aig_Man_t * pAig, int Num )
-{
-    Llb_Mnn_t * pMnn;
-    Gia_ParLlb_t Pars, * pPars = &Pars;
-    Aig_Man_t * p;
-    abctime clk = Abc_Clock();
-
-    Llb_ManSetDefaultParams( pPars );
-    pPars->fVerbose = 1;
-
-    p = Aig_ManDupFlopsOnly( pAig );
-//Aig_ManShow( p, 0, NULL );
-    Aig_ManPrintStats( pAig );
-    Aig_ManPrintStats( p );
-
-    pMnn = Llb_MnnStart( pAig, p, pPars );
-    Llb_NonlinReachability( pMnn );
-    pMnn->timeTotal = Abc_Clock() - clk;
-    Llb_MnnStop( pMnn );
-
-    Aig_ManStop( p );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Finds balanced cut.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_NonlinCoreReach( Aig_Man_t * pAig, Gia_ParLlb_t * pPars )
-{
-    Llb_Mnn_t * pMnn;
-    Aig_Man_t * p;
-    int RetValue = -1;
-
-    p = Aig_ManDupFlopsOnly( pAig );
-//Aig_ManShow( p, 0, NULL );
-    if ( pPars->fVerbose )
-    Aig_ManPrintStats( pAig );
-    if ( pPars->fVerbose )
-    Aig_ManPrintStats( p );
-
-    if ( !pPars->fSkipReach )
-    {
-        abctime clk = Abc_Clock();
-        pMnn = Llb_MnnStart( pAig, p, pPars );
-        RetValue = Llb_NonlinReachability( pMnn );
-        pMnn->timeTotal = Abc_Clock() - clk;
-        Llb_MnnStop( pMnn );
-    }
-
-    Aig_ManStop( p );
-    return RetValue;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/llb/llb4Cex.c b/src/proof/llb/llb4Cex.c
deleted file mode 100644
index 18aeaf04..00000000
--- a/src/proof/llb/llb4Cex.c
+++ /dev/null
@@ -1,320 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [llb2Cex.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD based reachability.]
-
-  Synopsis    [Non-linear quantification scheduling.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: llb2Cex.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "llbInt.h"
-#include "sat/cnf/cnf.h"
-#include "sat/bsat/satSolver.h"
-
-ABC_NAMESPACE_IMPL_START
- 
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Translates a sequence of states into a counter-example.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Abc_Cex_t * Llb4_Nonlin4TransformCex( Aig_Man_t * pAig, Vec_Ptr_t * vStates, int iCexPo, int fVerbose )
-{
-    Abc_Cex_t * pCex;
-    Cnf_Dat_t * pCnf;
-    Vec_Int_t * vAssumps;
-    sat_solver * pSat;
-    Aig_Obj_t * pObj;
-    unsigned * pNext, * pThis;
-    int i, k, iBit, status, nRegs;//, clk = Abc_Clock();
-/*
-    Vec_PtrForEachEntry( unsigned *, vStates, pNext, i )
-    {
-        printf( "%4d : ", i );
-        Extra_PrintBinary( stdout, pNext, Aig_ManRegNum(pAig) );
-        printf( "\n" );
-    }
-*/
-    // derive SAT solver
-    nRegs = Aig_ManRegNum(pAig); pAig->nRegs = 0;
-    pCnf = Cnf_Derive( pAig, Aig_ManCoNum(pAig) );
-    pAig->nRegs = nRegs;
-//    Cnf_DataTranformPolarity( pCnf, 0 );
-    // convert into SAT solver
-    pSat = (sat_solver *)Cnf_DataWriteIntoSolver( pCnf, 1, 0 );
-    if ( pSat == NULL )
-    {
-        printf( "Llb4_Nonlin4TransformCex(): Counter-example generation has failed.\n" );
-        Cnf_DataFree( pCnf );
-        return NULL;
-    }
-    // simplify the problem
-    status = sat_solver_simplify(pSat);
-    if ( status == 0 )
-    {
-        printf( "Llb4_Nonlin4TransformCex(): SAT solver is invalid.\n" );
-        sat_solver_delete( pSat );
-        Cnf_DataFree( pCnf );
-        return NULL;
-    }
-    // start the counter-example
-    pCex = Abc_CexAlloc( Saig_ManRegNum(pAig), Saig_ManPiNum(pAig), Vec_PtrSize(vStates) );
-    pCex->iFrame = Vec_PtrSize(vStates)-1;
-    pCex->iPo = -1;
-
-    // solve each time frame
-    iBit = Saig_ManRegNum(pAig);
-    pThis = (unsigned *)Vec_PtrEntry( vStates, 0 );
-    vAssumps = Vec_IntAlloc( 2 * Aig_ManRegNum(pAig) );
-    Vec_PtrForEachEntryStart( unsigned *, vStates, pNext, i, 1 )
-    {
-        // create assumptions
-        Vec_IntClear( vAssumps );
-        Saig_ManForEachLo( pAig, pObj, k )
-            Vec_IntPush( vAssumps, toLitCond( pCnf->pVarNums[Aig_ObjId(pObj)], !Abc_InfoHasBit(pThis,k) ) );
-        Saig_ManForEachLi( pAig, pObj, k )
-            Vec_IntPush( vAssumps, toLitCond( pCnf->pVarNums[Aig_ObjId(pObj)], !Abc_InfoHasBit(pNext,k) ) );
-        // solve SAT problem
-        status = sat_solver_solve( pSat, Vec_IntArray(vAssumps), Vec_IntArray(vAssumps) + Vec_IntSize(vAssumps), 
-            (ABC_INT64_T)0, (ABC_INT64_T)0, (ABC_INT64_T)0, (ABC_INT64_T)0 );
-        // if the problem is SAT, get the counterexample
-        if ( status != l_True )
-        {
-            printf( "Llb4_Nonlin4TransformCex(): There is no transition between state %d and %d.\n", i-1, i );
-            Vec_IntFree( vAssumps );
-            sat_solver_delete( pSat );
-            Cnf_DataFree( pCnf );
-            ABC_FREE( pCex );
-            return NULL;
-        }
-        // get the assignment of PIs
-        Saig_ManForEachPi( pAig, pObj, k )
-            if ( sat_solver_var_value(pSat, pCnf->pVarNums[Aig_ObjId(pObj)]) )
-                Abc_InfoSetBit( pCex->pData, iBit + k );
-        // update the counter
-        iBit += Saig_ManPiNum(pAig);
-        pThis = pNext;
-    }
-
-    // add the last frame when the property fails
-    Vec_IntClear( vAssumps );
-    if ( iCexPo >= 0 )
-    {
-        Saig_ManForEachPo( pAig, pObj, k )
-            if ( k == iCexPo )
-                Vec_IntPush( vAssumps, toLitCond( pCnf->pVarNums[Aig_ObjId(pObj)], 0 ) );
-    }
-    else
-    {
-        Saig_ManForEachPo( pAig, pObj, k )
-            Vec_IntPush( vAssumps, toLitCond( pCnf->pVarNums[Aig_ObjId(pObj)], 0 ) );
-    }
-
-    // add clause
-    status = sat_solver_addclause( pSat, Vec_IntArray(vAssumps), Vec_IntArray(vAssumps) + Vec_IntSize(vAssumps) );
-    if ( status == 0 )
-    {
-        printf( "Llb4_Nonlin4TransformCex(): The SAT solver is unsat after adding last clause.\n" );
-        Vec_IntFree( vAssumps );
-        sat_solver_delete( pSat );
-        Cnf_DataFree( pCnf );
-        ABC_FREE( pCex );
-        return NULL;
-    }
-    // create assumptions
-    Vec_IntClear( vAssumps );
-    Saig_ManForEachLo( pAig, pObj, k )
-        Vec_IntPush( vAssumps, toLitCond( pCnf->pVarNums[Aig_ObjId(pObj)], !Abc_InfoHasBit(pThis,k) ) );
-    // solve the last frame
-    status = sat_solver_solve( pSat, Vec_IntArray(vAssumps), Vec_IntArray(vAssumps) + Vec_IntSize(vAssumps), 
-        (ABC_INT64_T)0, (ABC_INT64_T)0, (ABC_INT64_T)0, (ABC_INT64_T)0 );
-    if ( status != l_True )
-    {
-        printf( "Llb4_Nonlin4TransformCex(): There is no last transition that makes the property fail.\n" );
-        Vec_IntFree( vAssumps );
-        sat_solver_delete( pSat );
-        Cnf_DataFree( pCnf );
-        ABC_FREE( pCex );
-        return NULL;
-    }
-    // get the assignment of PIs
-    Saig_ManForEachPi( pAig, pObj, k )
-        if ( sat_solver_var_value(pSat, pCnf->pVarNums[Aig_ObjId(pObj)]) )
-            Abc_InfoSetBit( pCex->pData, iBit + k );
-    iBit += Saig_ManPiNum(pAig);
-    assert( iBit == pCex->nBits );
-
-    // free the sat_solver
-    Vec_IntFree( vAssumps );
-    sat_solver_delete( pSat );
-    Cnf_DataFree( pCnf );
-
-    // verify counter-example
-    status = Saig_ManFindFailedPoCex( pAig, pCex );
-    if ( status >= 0 && status < Saig_ManPoNum(pAig) )
-        pCex->iPo = status;
-    else
-    {
-        printf( "Llb4_Nonlin4TransformCex(): Counter-example verification has FAILED.\n" );
-        ABC_FREE( pCex );
-        return NULL;
-    }
-    // report the results
-//    if ( fVerbose )
-//       Abc_PrintTime( 1, "SAT-based cex generation time", Abc_Clock() - clk );
-    return pCex;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Resimulates the counter-example.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Ptr_t * Llb4_Nonlin4VerifyCex( Aig_Man_t * pAig, Abc_Cex_t * p )
-{
-    Vec_Ptr_t * vStates;
-    Aig_Obj_t * pObj, * pObjRi, * pObjRo;
-    int i, k, iBit = 0;
-    // create storage for states
-    vStates = Vec_PtrAllocSimInfo( p->iFrame+1, Abc_BitWordNum(Aig_ManRegNum(pAig)) );
-    Vec_PtrCleanSimInfo( vStates, 0, Abc_BitWordNum(Aig_ManRegNum(pAig)) );
-    // verify counter-example
-    Aig_ManCleanMarkB(pAig);
-    Aig_ManConst1(pAig)->fMarkB = 1;
-    Saig_ManForEachLo( pAig, pObj, i )
-        pObj->fMarkB = 0; //Abc_InfoHasBit(p->pData, iBit++);
-    // do not require equal flop count in the AIG and in the CEX
-    iBit = p->nRegs;
-    for ( i = 0; i <= p->iFrame; i++ )
-    {
-        // save current state
-        Saig_ManForEachLo( pAig, pObj, k )
-            if ( pObj->fMarkB )
-                Abc_InfoSetBit( (unsigned *)Vec_PtrEntry(vStates, i), k );
-        // compute new state
-        Saig_ManForEachPi( pAig, pObj, k )
-            pObj->fMarkB = Abc_InfoHasBit(p->pData, iBit++);
-        Aig_ManForEachNode( pAig, pObj, k )
-            pObj->fMarkB = (Aig_ObjFanin0(pObj)->fMarkB ^ Aig_ObjFaninC0(pObj)) & 
-                           (Aig_ObjFanin1(pObj)->fMarkB ^ Aig_ObjFaninC1(pObj));
-        Aig_ManForEachCo( pAig, pObj, k )
-            pObj->fMarkB = Aig_ObjFanin0(pObj)->fMarkB ^ Aig_ObjFaninC0(pObj);
-        if ( i == p->iFrame )
-            break;
-        Saig_ManForEachLiLo( pAig, pObjRi, pObjRo, k )
-            pObjRo->fMarkB = pObjRi->fMarkB;
-    }
-/*
-    {
-        unsigned * pNext;
-        Vec_PtrForEachEntry( unsigned *, vStates, pNext, i )
-        {
-            printf( "%4d : ", i );
-            Extra_PrintBinary( stdout, pNext, Aig_ManRegNum(pAig) );
-            printf( "\n" );
-        }
-    }
-*/
-    assert( iBit == p->nBits );
-//    if ( Aig_ManCo(pAig, p->iPo)->fMarkB == 0 )
-//        Vec_PtrFreeP( &vStates );
-    for ( i = Saig_ManPoNum(pAig) - 1; i >= 0; i-- )
-    {
-        if ( Aig_ManCo(pAig, i)->fMarkB )
-        {
-            p->iPo = i;
-            break;
-        }
-    }
-    if ( i == -1 )
-        Vec_PtrFreeP( &vStates );
-    Aig_ManCleanMarkB(pAig);
-    return vStates;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Translates a sequence of states into a counter-example.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Abc_Cex_t * Llb4_Nonlin4NormalizeCex( Aig_Man_t * pAigOrg, Aig_Man_t * pAigRpm, Abc_Cex_t * pCexRpm )
-{
-    Abc_Cex_t * pCexOrg;
-    Vec_Ptr_t * vStates;
-    // check parameters of the AIG
-    if ( Saig_ManRegNum(pAigOrg) != Saig_ManRegNum(pAigRpm) )
-    {
-        printf( "Llb4_Nonlin4NormalizeCex(): The number of flops in the original and reparametrized AIGs do not agree.\n" );
-        return NULL;
-    }
-/*
-    if ( Saig_ManRegNum(pAigRpm) != pCexRpm->nRegs )
-    {
-        printf( "Llb4_Nonlin4NormalizeCex(): The number of flops in the reparametrized AIG and in the CEX do not agree.\n" );
-        return NULL;
-    }
-*/
-    if ( Saig_ManPiNum(pAigRpm) != pCexRpm->nPis )
-    {
-        printf( "Llb4_Nonlin4NormalizeCex(): The number of PIs in the reparametrized AIG and in the CEX do not agree.\n" );
-        return NULL;
-    }
-    // get the sequence of states
-    vStates = Llb4_Nonlin4VerifyCex( pAigRpm, pCexRpm );
-    if ( vStates == NULL )
-    {
-        Abc_Print( 1, "Llb4_Nonlin4NormalizeCex(): The given CEX does not fail outputs of pAigRpm.\n" );
-        return NULL;
-    }
-    // derive updated counter-example
-    pCexOrg = Llb4_Nonlin4TransformCex( pAigOrg, vStates, pCexRpm->iPo, 0 );
-    Vec_PtrFree( vStates );
-    return pCexOrg;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/llb/llb4Cluster.c b/src/proof/llb/llb4Cluster.c
deleted file mode 100644
index 7e325597..00000000
--- a/src/proof/llb/llb4Cluster.c
+++ /dev/null
@@ -1,452 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [llb2Cluster.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD based reachability.]
-
-  Synopsis    [Non-linear quantification scheduling.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: llb2Cluster.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "llbInt.h"
-
-ABC_NAMESPACE_IMPL_START
- 
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Find good static variable ordering.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_Nonlin4FindOrder_rec( Aig_Man_t * pAig, Aig_Obj_t * pObj, Vec_Int_t * vOrder, int * pCounter )
-{
-    Aig_Obj_t * pFanin0, * pFanin1;
-    if ( Aig_ObjIsTravIdCurrent(pAig, pObj) )
-        return;
-    Aig_ObjSetTravIdCurrent( pAig, pObj );
-    assert( Llb_ObjBddVar(vOrder, pObj) < 0 );
-    if ( Aig_ObjIsCi(pObj) )
-    {
-        Vec_IntWriteEntry( vOrder, Aig_ObjId(pObj), (*pCounter)++ );
-        return;
-    }
-    // try fanins with higher level first
-    pFanin0 = Aig_ObjFanin0(pObj);
-    pFanin1 = Aig_ObjFanin1(pObj);
-//    if ( pFanin0->Level > pFanin1->Level || (pFanin0->Level == pFanin1->Level && pFanin0->Id < pFanin1->Id) )
-    if ( pFanin0->Level > pFanin1->Level )
-    {
-        Llb_Nonlin4FindOrder_rec( pAig, pFanin0, vOrder, pCounter );
-        Llb_Nonlin4FindOrder_rec( pAig, pFanin1, vOrder, pCounter );
-    }
-    else
-    {
-        Llb_Nonlin4FindOrder_rec( pAig, pFanin1, vOrder, pCounter );
-        Llb_Nonlin4FindOrder_rec( pAig, pFanin0, vOrder, pCounter );
-    }
-    if ( pObj->fMarkA )
-        Vec_IntWriteEntry( vOrder, Aig_ObjId(pObj), (*pCounter)++ );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Find good static variable ordering.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Int_t * Llb_Nonlin4FindOrder( Aig_Man_t * pAig, int * pCounter )
-{
-    Vec_Int_t * vNodes = NULL;
-    Vec_Int_t * vOrder;
-    Aig_Obj_t * pObj;
-    int i, Counter = 0;
-    // mark nodes to exclude:  AND with low level and CO drivers
-    Aig_ManCleanMarkA( pAig );
-    Aig_ManForEachNode( pAig, pObj, i )
-        if ( Aig_ObjLevel(pObj) > 3 )
-            pObj->fMarkA = 1;
-    Aig_ManForEachCo( pAig, pObj, i )
-        Aig_ObjFanin0(pObj)->fMarkA = 0;
-
-    // collect nodes in the order
-    vOrder = Vec_IntStartFull( Aig_ManObjNumMax(pAig) );
-    Aig_ManIncrementTravId( pAig );
-    Aig_ObjSetTravIdCurrent( pAig, Aig_ManConst1(pAig) );
-//    Aig_ManForEachCo( pAig, pObj, i )
-    Saig_ManForEachLi( pAig, pObj, i )
-    {
-        Vec_IntWriteEntry( vOrder, Aig_ObjId(pObj), Counter++ );
-        Llb_Nonlin4FindOrder_rec( pAig, Aig_ObjFanin0(pObj), vOrder, &Counter );
-    }
-    Aig_ManForEachCi( pAig, pObj, i )
-        if ( Llb_ObjBddVar(vOrder, pObj) < 0 )
-            Vec_IntWriteEntry( vOrder, Aig_ObjId(pObj), Counter++ );
-    Aig_ManCleanMarkA( pAig );
-    Vec_IntFreeP( &vNodes );
-//    assert( Counter == Aig_ManObjNum(pAig) - 1 );
-
-/*
-    Saig_ManForEachPi( pAig, pObj, i )
-        printf( "pi%d ", Llb_ObjBddVar(vOrder, pObj) );
-    printf( "\n" );
-    Saig_ManForEachLo( pAig, pObj, i )
-        printf( "lo%d ", Llb_ObjBddVar(vOrder, pObj) );
-    printf( "\n" );
-    Saig_ManForEachPo( pAig, pObj, i )
-        printf( "po%d ", Llb_ObjBddVar(vOrder, pObj) );
-    printf( "\n" );
-    Saig_ManForEachLi( pAig, pObj, i )
-        printf( "li%d ", Llb_ObjBddVar(vOrder, pObj) );
-    printf( "\n" );
-    Aig_ManForEachNode( pAig, pObj, i )
-        printf( "n%d ", Llb_ObjBddVar(vOrder, pObj) );
-    printf( "\n" );
-*/
-    if ( pCounter )
-        *pCounter = Counter;
-    return vOrder;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Derives BDDs for the partitions.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb_Nonlin4FindPartitions_rec( DdManager * dd, Aig_Obj_t * pObj, Vec_Int_t * vOrder, Vec_Ptr_t * vRoots )
-{
-    DdNode * bBdd, * bBdd0, * bBdd1, * bPart, * vVar;
-    if ( Aig_ObjIsConst1(pObj) )
-        return Cudd_ReadOne(dd); 
-    if ( Aig_ObjIsCi(pObj) )
-        return Cudd_bddIthVar( dd, Llb_ObjBddVar(vOrder, pObj) );
-    if ( pObj->pData )
-        return (DdNode *)pObj->pData;
-    if ( Aig_ObjIsCo(pObj) )
-    {
-        bBdd0 = Cudd_NotCond( Llb_Nonlin4FindPartitions_rec(dd, Aig_ObjFanin0(pObj), vOrder, vRoots), Aig_ObjFaninC0(pObj) );
-        bPart = Cudd_bddXnor( dd, Cudd_bddIthVar( dd, Llb_ObjBddVar(vOrder, pObj) ), bBdd0 );  Cudd_Ref( bPart );
-        Vec_PtrPush( vRoots, bPart );
-        return NULL;
-    }
-    bBdd0 = Cudd_NotCond( Llb_Nonlin4FindPartitions_rec(dd, Aig_ObjFanin0(pObj), vOrder, vRoots), Aig_ObjFaninC0(pObj) );
-    bBdd1 = Cudd_NotCond( Llb_Nonlin4FindPartitions_rec(dd, Aig_ObjFanin1(pObj), vOrder, vRoots), Aig_ObjFaninC1(pObj) );
-    bBdd  = Cudd_bddAnd( dd, bBdd0, bBdd1 );   Cudd_Ref( bBdd );
-    if ( Llb_ObjBddVar(vOrder, pObj) >= 0 )
-    {
-        vVar  = Cudd_bddIthVar( dd, Llb_ObjBddVar(vOrder, pObj) );
-        bPart = Cudd_bddXnor( dd, vVar, bBdd );  Cudd_Ref( bPart );
-        Vec_PtrPush( vRoots, bPart );
-        Cudd_RecursiveDeref( dd, bBdd );
-        bBdd = vVar;  Cudd_Ref( vVar );
-    }
-    pObj->pData = bBdd;
-    return bBdd;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Derives BDDs for the partitions.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Ptr_t * Llb_Nonlin4FindPartitions( DdManager * dd, Aig_Man_t * pAig, Vec_Int_t * vOrder, int fOutputs )
-{
-    Vec_Ptr_t * vRoots;
-    Aig_Obj_t * pObj;
-    int i;
-    Aig_ManCleanData( pAig );
-    vRoots = Vec_PtrAlloc( 100 );
-    if ( fOutputs )
-    {
-        Saig_ManForEachPo( pAig, pObj, i )
-            Llb_Nonlin4FindPartitions_rec( dd, pObj, vOrder, vRoots );
-    }
-    else
-    {
-        Saig_ManForEachLi( pAig, pObj, i )
-            Llb_Nonlin4FindPartitions_rec( dd, pObj, vOrder, vRoots );
-    }
-    Aig_ManForEachNode( pAig, pObj, i )
-        if ( pObj->pData )
-            Cudd_RecursiveDeref( dd, (DdNode *)pObj->pData );
-    return vRoots;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Creates quantifiable variables for both types of traversal.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Int_t * Llb_Nonlin4FindVars2Q( DdManager * dd, Aig_Man_t * pAig, Vec_Int_t * vOrder )
-{
-    Vec_Int_t * vVars2Q;
-    Aig_Obj_t * pObj;
-    int i;
-    vVars2Q = Vec_IntAlloc( 0 );
-    Vec_IntFill( vVars2Q, Cudd_ReadSize(dd), 1 );
-    Saig_ManForEachLo( pAig, pObj, i )
-        Vec_IntWriteEntry( vVars2Q, Llb_ObjBddVar(vOrder, pObj), 0 );
-//    Aig_ManForEachCo( pAig, pObj, i )
-    Saig_ManForEachLi( pAig, pObj, i )
-        Vec_IntWriteEntry( vVars2Q, Llb_ObjBddVar(vOrder, pObj), 0 );
-    return vVars2Q;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Creates quantifiable variables for both types of traversal.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_Nonlin4CountTerms( DdManager * dd, Aig_Man_t * pAig, Vec_Int_t * vOrder, DdNode * bFunc, int fCo, int fFlop )
-{
-    DdNode * bSupp;
-    Aig_Obj_t * pObj;
-    int i, Counter = 0;
-    bSupp = Cudd_Support( dd, bFunc );  Cudd_Ref( bSupp );
-    if ( !fCo && !fFlop )
-    {
-        Saig_ManForEachPi( pAig, pObj, i )
-            if ( Llb_ObjBddVar(vOrder, pObj) >= 0 )
-                Counter += Cudd_bddLeq( dd, bSupp, Cudd_bddIthVar(dd, Llb_ObjBddVar(vOrder, pObj)) );
-    }
-    else if ( fCo && !fFlop )
-    {
-        Saig_ManForEachPo( pAig, pObj, i )
-            if ( Llb_ObjBddVar(vOrder, pObj) >= 0 )
-                Counter += Cudd_bddLeq( dd, bSupp, Cudd_bddIthVar(dd, Llb_ObjBddVar(vOrder, pObj)) );
-    }
-    else if ( !fCo && fFlop )
-    {
-        Saig_ManForEachLo( pAig, pObj, i )
-            if ( Llb_ObjBddVar(vOrder, pObj) >= 0 )
-                Counter += Cudd_bddLeq( dd, bSupp, Cudd_bddIthVar(dd, Llb_ObjBddVar(vOrder, pObj)) );
-    }
-    else if ( fCo && fFlop )
-    {
-        Saig_ManForEachLi( pAig, pObj, i )
-            if ( Llb_ObjBddVar(vOrder, pObj) >= 0 )
-                Counter += Cudd_bddLeq( dd, bSupp, Cudd_bddIthVar(dd, Llb_ObjBddVar(vOrder, pObj)) );
-    }
-    Cudd_RecursiveDeref( dd, bSupp );
-    return Counter;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Creates quantifiable variables for both types of traversal.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_Nonlin4PrintGroups( DdManager * dd, Aig_Man_t * pAig, Vec_Int_t * vOrder, Vec_Ptr_t * vGroups )
-{
-    DdNode * bTemp;
-    int i, nSuppAll, nSuppPi, nSuppPo, nSuppLi, nSuppLo, nSuppAnd;
-    Vec_PtrForEachEntry( DdNode *, vGroups, bTemp, i )
-    {
-//Extra_bddPrintSupport(dd, bTemp);  printf("\n" );
-        nSuppAll = Cudd_SupportSize(dd,bTemp);
-        nSuppPi  = Llb_Nonlin4CountTerms(dd, pAig, vOrder, bTemp, 0, 0);
-        nSuppPo  = Llb_Nonlin4CountTerms(dd, pAig, vOrder, bTemp, 1, 0);
-        nSuppLi  = Llb_Nonlin4CountTerms(dd, pAig, vOrder, bTemp, 0, 1);
-        nSuppLo  = Llb_Nonlin4CountTerms(dd, pAig, vOrder, bTemp, 1, 1);
-        nSuppAnd = nSuppAll - (nSuppPi+nSuppPo+nSuppLi+nSuppLo);
-
-        if ( Cudd_DagSize(bTemp) <= 10 )
-            continue;
-
-        printf( "%4d : bdd =%6d  supp =%3d  ", i, Cudd_DagSize(bTemp), nSuppAll );
-        printf( "pi =%3d ",  nSuppPi );
-        printf( "po =%3d ",  nSuppPo );
-        printf( "lo =%3d ",  nSuppLo );
-        printf( "li =%3d ",  nSuppLi );
-        printf( "and =%3d",  nSuppAnd );
-        printf( "\n" );
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Creates quantifiable variables for both types of traversal.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_Nonlin4PrintSuppProfile( DdManager * dd, Aig_Man_t * pAig, Vec_Int_t * vOrder, Vec_Ptr_t * vGroups )
-{
-    Aig_Obj_t * pObj;
-    int i, * pSupp;
-    int nSuppAll = 0, nSuppPi = 0, nSuppPo = 0, nSuppLi = 0, nSuppLo = 0, nSuppAnd = 0;
-
-    pSupp = ABC_CALLOC( int, Cudd_ReadSize(dd) );
-    Extra_VectorSupportArray( dd, (DdNode **)Vec_PtrArray(vGroups), Vec_PtrSize(vGroups), pSupp );
-
-    Aig_ManForEachObj( pAig, pObj, i )
-    {
-        if ( Llb_ObjBddVar(vOrder, pObj) < 0 )
-            continue;
-        // remove variables that do not participate
-        if ( pSupp[Llb_ObjBddVar(vOrder, pObj)] == 0 )
-        {
-            if ( Aig_ObjIsNode(pObj) )
-                Vec_IntWriteEntry( vOrder, Aig_ObjId(pObj), -1 );
-            continue;
-        }
-        nSuppAll++;
-        if ( Saig_ObjIsPi(pAig, pObj) )
-            nSuppPi++;
-        else if ( Saig_ObjIsLo(pAig, pObj) )
-            nSuppLo++;
-        else if ( Saig_ObjIsPo(pAig, pObj) )
-            nSuppPo++;
-        else if ( Saig_ObjIsLi(pAig, pObj) )
-            nSuppLi++;
-        else
-            nSuppAnd++;
-    }
-    ABC_FREE( pSupp );
-
-    printf( "Groups =%3d  ", Vec_PtrSize(vGroups) );
-    printf( "Variables: all =%4d ",  nSuppAll );
-    printf( "pi =%4d ",  nSuppPi );
-    printf( "po =%4d ",  nSuppPo );
-    printf( "lo =%4d ",  nSuppLo );
-    printf( "li =%4d ",  nSuppLi );
-    printf( "and =%4d",  nSuppAnd );
-    printf( "\n" );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_Nonlin4Cluster( Aig_Man_t * pAig, DdManager ** pdd, Vec_Int_t ** pvOrder, Vec_Ptr_t ** pvGroups, int nBddMax, int fVerbose )
-{
-    DdManager * dd;
-    Vec_Int_t * vOrder, * vVars2Q;
-    Vec_Ptr_t * vParts, * vGroups;
-    DdNode * bTemp;
-    int i, nVarNum;
-
-    // create the BDD manager
-    vOrder  = Llb_Nonlin4FindOrder( pAig, &nVarNum );
-    dd      = Cudd_Init( nVarNum, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
-//    Cudd_AutodynEnable( dd,  CUDD_REORDER_SYMM_SIFT );
-
-    vVars2Q = Llb_Nonlin4FindVars2Q( dd, pAig, vOrder );
-    vParts  = Llb_Nonlin4FindPartitions( dd, pAig, vOrder, 0 );
-
-    vGroups = Llb_Nonlin4Group( dd, vParts, vVars2Q, nBddMax );
-    Vec_IntFree( vVars2Q );
-
-    Vec_PtrForEachEntry( DdNode *, vParts, bTemp, i )
-        Cudd_RecursiveDeref( dd, bTemp );
-    Vec_PtrFree( vParts );
-
-
-//    if ( fVerbose )
-    Llb_Nonlin4PrintSuppProfile( dd, pAig, vOrder, vGroups );
-    if ( fVerbose )
-    printf( "Before reordering\n" );
-    if ( fVerbose )
-    Llb_Nonlin4PrintGroups( dd, pAig, vOrder, vGroups );
-
-//    Cudd_ReduceHeap( dd, CUDD_REORDER_SYMM_SIFT, 1 );
-//    printf( "After reordering\n" );
-//    Llb_Nonlin4PrintGroups( dd, pAig, vOrder, vGroups );
-
-    if ( pvOrder )
-        *pvOrder = vOrder;
-    else
-        Vec_IntFree( vOrder );
-
-    if ( pvGroups )
-        *pvGroups = vGroups;
-    else
-    {
-        Vec_PtrForEachEntry( DdNode *, vGroups, bTemp, i )
-            Cudd_RecursiveDeref( dd, bTemp );
-        Vec_PtrFree( vGroups );
-    }
-
-    if ( pdd )
-        *pdd = dd;
-    else
-        Extra_StopManager( dd );
-//    Cudd_Quit( dd );
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/llb/llb4Image.c b/src/proof/llb/llb4Image.c
deleted file mode 100644
index 2ba4fcfd..00000000
--- a/src/proof/llb/llb4Image.c
+++ /dev/null
@@ -1,863 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [llb3Image.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD based reachability.]
-
-  Synopsis    [Computes image using partitioned structure.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: llb3Image.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "llbInt.h"
-
-ABC_NAMESPACE_IMPL_START
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-typedef struct Llb_Var_t_ Llb_Var_t;
-struct Llb_Var_t_ 
-{
-    int           iVar;      // variable number
-    int           nScore;    // variable score
-    Vec_Int_t *   vParts;    // partitions
-};
-
-typedef struct Llb_Prt_t_ Llb_Prt_t;
-struct Llb_Prt_t_ 
-{
-    int           iPart;     // partition number
-    int           nSize;     // the number of BDD nodes
-    DdNode *      bFunc;     // the partition
-    Vec_Int_t *   vVars;     // support
-};
-
-typedef struct Llb_Mgr_t_ Llb_Mgr_t;
-struct Llb_Mgr_t_
-{
-    DdManager *   dd;        // working BDD manager
-    Vec_Int_t *   vVars2Q;   // variables to quantify
-    int           nSizeMax;  // maximum size of the cluster
-    // internal
-    Llb_Prt_t **  pParts;    // partitions
-    Llb_Var_t **  pVars;     // variables
-    int           iPartFree; // next free partition
-    int           nVars;     // the number of BDD variables
-    int           nSuppMax;  // maximum support size
-    // temporary
-    int *         pSupp;     // temporary support storage
-};
-
-static inline Llb_Var_t * Llb_MgrVar( Llb_Mgr_t * p, int i )   { return p->pVars[i];  }
-static inline Llb_Prt_t * Llb_MgrPart( Llb_Mgr_t * p, int i )  { return p->pParts[i]; }
-
-// iterator over vars
-#define Llb_MgrForEachVar( p, pVar, i )     \
-    for ( i = 0; (i < p->nVars) && (((pVar) = Llb_MgrVar(p, i)), 1); i++ ) if ( pVar == NULL ) {} else
-// iterator over parts
-#define Llb_MgrForEachPart( p, pPart, i )   \
-    for ( i = 0; (i < p->iPartFree) && (((pPart) = Llb_MgrPart(p, i)), 1); i++ ) if ( pPart == NULL ) {} else
-
-// iterator over vars of one partition
-#define Llb_PartForEachVar( p, pPart, pVar, i )   \
-    for ( i = 0; (i < Vec_IntSize(pPart->vVars)) && (((pVar) = Llb_MgrVar(p, Vec_IntEntry(pPart->vVars,i))), 1); i++ )
-// iterator over parts of one variable
-#define Llb_VarForEachPart( p, pVar, pPart, i )   \
-    for ( i = 0; (i < Vec_IntSize(pVar->vParts)) && (((pPart) = Llb_MgrPart(p, Vec_IntEntry(pVar->vParts,i))), 1); i++ )
-
-// statistics
-//abctime timeBuild, timeAndEx, timeOther;
-//int nSuppMax;
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Removes one variable.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_Nonlin4RemoveVar( Llb_Mgr_t * p, Llb_Var_t * pVar )
-{
-    assert( p->pVars[pVar->iVar] == pVar );
-    p->pVars[pVar->iVar] = NULL;
-    Vec_IntFree( pVar->vParts );
-    ABC_FREE( pVar );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Removes one partition.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_Nonlin4RemovePart( Llb_Mgr_t * p, Llb_Prt_t * pPart )
-{
-//printf( "Removing %d\n", pPart->iPart );
-    assert( p->pParts[pPart->iPart] == pPart );
-    p->pParts[pPart->iPart] = NULL;
-    Vec_IntFree( pPart->vVars );
-    Cudd_RecursiveDeref( p->dd, pPart->bFunc );
-    ABC_FREE( pPart );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Create cube with singleton variables.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb_Nonlin4CreateCube1( Llb_Mgr_t * p, Llb_Prt_t * pPart )
-{
-    DdNode * bCube, * bTemp;
-    Llb_Var_t * pVar;
-    int i;
-    abctime TimeStop;
-    TimeStop = p->dd->TimeStop; p->dd->TimeStop = 0;
-    bCube = Cudd_ReadOne(p->dd);   Cudd_Ref( bCube );
-    Llb_PartForEachVar( p, pPart, pVar, i )
-    {
-        assert( Vec_IntSize(pVar->vParts) > 0 );
-        if ( Vec_IntSize(pVar->vParts) != 1 )
-            continue;
-        assert( Vec_IntEntry(pVar->vParts, 0) == pPart->iPart );
-        bCube = Cudd_bddAnd( p->dd, bTemp = bCube, Cudd_bddIthVar(p->dd, pVar->iVar) );    Cudd_Ref( bCube );
-        Cudd_RecursiveDeref( p->dd, bTemp );
-    }
-    Cudd_Deref( bCube );
-    p->dd->TimeStop = TimeStop;
-    return bCube;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Create cube of variables appearing only in two partitions.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb_Nonlin4CreateCube2( Llb_Mgr_t * p, Llb_Prt_t * pPart1, Llb_Prt_t * pPart2 )
-{
-    DdNode * bCube, * bTemp;
-    Llb_Var_t * pVar;
-    int i;
-    abctime TimeStop;
-    TimeStop = p->dd->TimeStop; p->dd->TimeStop = 0;
-    bCube = Cudd_ReadOne(p->dd);   Cudd_Ref( bCube );
-    Llb_PartForEachVar( p, pPart1, pVar, i )
-    {
-        assert( Vec_IntSize(pVar->vParts) > 0 );
-        if ( Vec_IntSize(pVar->vParts) != 2 )
-            continue;
-        if ( (Vec_IntEntry(pVar->vParts, 0) == pPart1->iPart && Vec_IntEntry(pVar->vParts, 1) == pPart2->iPart) ||
-             (Vec_IntEntry(pVar->vParts, 0) == pPart2->iPart && Vec_IntEntry(pVar->vParts, 1) == pPart1->iPart) )
-        {
-            bCube = Cudd_bddAnd( p->dd, bTemp = bCube, Cudd_bddIthVar(p->dd, pVar->iVar) );   Cudd_Ref( bCube );
-            Cudd_RecursiveDeref( p->dd, bTemp );
-        }
-    }
-    Cudd_Deref( bCube );
-    p->dd->TimeStop = TimeStop;
-    return bCube;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns 1 if partition has singleton variables.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_Nonlin4HasSingletonVars( Llb_Mgr_t * p, Llb_Prt_t * pPart )
-{
-    Llb_Var_t * pVar;
-    int i;
-    Llb_PartForEachVar( p, pPart, pVar, i )
-        if ( Vec_IntSize(pVar->vParts) == 1 )
-            return 1;
-    return 0;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns 1 if partition has singleton variables.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_Nonlin4Print( Llb_Mgr_t * p )
-{
-    Llb_Prt_t * pPart;
-    Llb_Var_t * pVar;
-    int i, k;
-    printf( "\n" );
-    Llb_MgrForEachVar( p, pVar, i )
-    {
-        printf( "Var %3d : ", i );
-        Llb_VarForEachPart( p, pVar, pPart, k )
-            printf( "%d ", pPart->iPart );
-        printf( "\n" );
-    }
-    Llb_MgrForEachPart( p, pPart, i )
-    {
-        printf( "Part %3d : ", i );
-        Llb_PartForEachVar( p, pPart, pVar, k )
-            printf( "%d ", pVar->iVar );
-        printf( "\n" );
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Quantifies singles belonging to one partition.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_Nonlin4Quantify1( Llb_Mgr_t * p, Llb_Prt_t * pPart )
-{
-    Llb_Var_t * pVar;
-    Llb_Prt_t * pTemp;
-    Vec_Ptr_t * vSingles;
-    DdNode * bCube, * bTemp;
-    int i, RetValue, nSizeNew;
-    // create cube to be quantified
-    bCube = Llb_Nonlin4CreateCube1( p, pPart );   Cudd_Ref( bCube );
-//    assert( !Cudd_IsConstant(bCube) );
-    // derive new function
-    pPart->bFunc = Cudd_bddExistAbstract( p->dd, bTemp = pPart->bFunc, bCube );  Cudd_Ref( pPart->bFunc );
-    Cudd_RecursiveDeref( p->dd, bTemp );
-    Cudd_RecursiveDeref( p->dd, bCube );
-    // get support
-    vSingles = Vec_PtrAlloc( 0 );
-    nSizeNew = Cudd_DagSize(pPart->bFunc);
-    Extra_SupportArray( p->dd, pPart->bFunc, p->pSupp );
-    Llb_PartForEachVar( p, pPart, pVar, i )
-        if ( p->pSupp[pVar->iVar] )
-        {
-            assert( Vec_IntSize(pVar->vParts) > 1 );
-            pVar->nScore -= pPart->nSize - nSizeNew;
-        }
-        else
-        {
-            RetValue = Vec_IntRemove( pVar->vParts, pPart->iPart );
-            assert( RetValue );
-            pVar->nScore -= pPart->nSize;
-            if ( Vec_IntSize(pVar->vParts) == 0 )
-                Llb_Nonlin4RemoveVar( p, pVar );
-            else if ( Vec_IntSize(pVar->vParts) == 1 )
-                Vec_PtrPushUnique( vSingles, Llb_MgrPart(p, Vec_IntEntry(pVar->vParts,0)) );
-        }
-
-    // update partition
-    pPart->nSize = nSizeNew;
-    Vec_IntClear( pPart->vVars );
-    for ( i = 0; i < p->nVars; i++ )
-        if ( p->pSupp[i] && Vec_IntEntry(p->vVars2Q, i) )
-            Vec_IntPush( pPart->vVars, i );
-    // remove other variables
-    Vec_PtrForEachEntry( Llb_Prt_t *, vSingles, pTemp, i )
-        Llb_Nonlin4Quantify1( p, pTemp );
-    Vec_PtrFree( vSingles );
-    return 0;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Quantifies singles belonging to one partition.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_Nonlin4Quantify2( Llb_Mgr_t * p, Llb_Prt_t * pPart1, Llb_Prt_t * pPart2 )
-{
-    int fVerbose = 0;
-    Llb_Var_t * pVar;
-    Llb_Prt_t * pTemp;
-    Vec_Ptr_t * vSingles;
-    DdNode * bCube, * bFunc;
-    int i, RetValue, nSuppSize;
-//    int iPart1 = pPart1->iPart;
-//    int iPart2 = pPart2->iPart;
-    int liveBeg, liveEnd;
-
-    // create cube to be quantified
-    bCube = Llb_Nonlin4CreateCube2( p, pPart1, pPart2 );   Cudd_Ref( bCube );
-
-//printf( "Quantifying  " ); Extra_bddPrintSupport( p->dd, bCube );  printf( "\n" );
-
-if ( fVerbose )
-{
-printf( "\n" );
-printf( "\n" );
-Llb_Nonlin4Print( p );
-printf( "Conjoining partitions %d and %d.\n", pPart1->iPart, pPart2->iPart );
-Extra_bddPrintSupport( p->dd, bCube );  printf( "\n" );
-}
-liveBeg = p->dd->keys - p->dd->dead;
-    bFunc = Cudd_bddAndAbstract( p->dd, pPart1->bFunc, pPart2->bFunc, bCube );  
-liveEnd = p->dd->keys - p->dd->dead;
-//printf( "%d ", liveEnd-liveBeg );
-
-    if ( bFunc == NULL )
-    {
-        Cudd_RecursiveDeref( p->dd, bCube );
-        return 0;
-    }
-    Cudd_Ref( bFunc );
-    Cudd_RecursiveDeref( p->dd, bCube );
-
-//printf( "Creating part %d ", p->iPartFree ); Extra_bddPrintSupport( p->dd, bFunc );  printf( "\n" );
-
-//printf( "Creating %d\n", p->iPartFree );
-
-    // create new partition
-    pTemp = p->pParts[p->iPartFree] = ABC_CALLOC( Llb_Prt_t, 1 );
-    pTemp->iPart = p->iPartFree++;
-    pTemp->nSize = Cudd_DagSize(bFunc);
-    pTemp->bFunc = bFunc;
-    pTemp->vVars = Vec_IntAlloc( 8 );
-    // update variables
-    Llb_PartForEachVar( p, pPart1, pVar, i )
-    {
-        RetValue = Vec_IntRemove( pVar->vParts, pPart1->iPart );
-        assert( RetValue );
-        pVar->nScore -= pPart1->nSize;
-    }
-    // update variables
-    Llb_PartForEachVar( p, pPart2, pVar, i )
-    {
-        RetValue = Vec_IntRemove( pVar->vParts, pPart2->iPart );
-        assert( RetValue );
-        pVar->nScore -= pPart2->nSize;
-    }
-    // add variables to the new partition
-    nSuppSize = 0;
-    Extra_SupportArray( p->dd, bFunc, p->pSupp );
-    for ( i = 0; i < p->nVars; i++ )
-    {
-        nSuppSize += p->pSupp[i];
-        if ( p->pSupp[i] && Vec_IntEntry(p->vVars2Q, i) )
-        {
-            pVar = Llb_MgrVar( p, i );
-            pVar->nScore += pTemp->nSize;
-            Vec_IntPush( pVar->vParts, pTemp->iPart );
-            Vec_IntPush( pTemp->vVars, i );
-        }
-    }
-    p->nSuppMax = Abc_MaxInt( p->nSuppMax, nSuppSize ); 
-    // remove variables and collect partitions with singleton variables
-    vSingles = Vec_PtrAlloc( 0 );
-    Llb_PartForEachVar( p, pPart1, pVar, i )
-    {
-        if ( Vec_IntSize(pVar->vParts) == 0 )
-            Llb_Nonlin4RemoveVar( p, pVar );
-        else if ( Vec_IntSize(pVar->vParts) == 1 )
-        {
-            if ( fVerbose )
-                printf( "Adding partition %d because of var %d.\n", 
-                    Llb_MgrPart(p, Vec_IntEntry(pVar->vParts,0))->iPart, pVar->iVar );
-            Vec_PtrPushUnique( vSingles, Llb_MgrPart(p, Vec_IntEntry(pVar->vParts,0)) );
-        }
-    }
-    Llb_PartForEachVar( p, pPart2, pVar, i )
-    {
-        if ( pVar == NULL )
-            continue;
-        if ( Vec_IntSize(pVar->vParts) == 0 )
-            Llb_Nonlin4RemoveVar( p, pVar );
-        else if ( Vec_IntSize(pVar->vParts) == 1 )
-        {
-            if ( fVerbose )
-                printf( "Adding partition %d because of var %d.\n", 
-                    Llb_MgrPart(p, Vec_IntEntry(pVar->vParts,0))->iPart, pVar->iVar );
-            Vec_PtrPushUnique( vSingles, Llb_MgrPart(p, Vec_IntEntry(pVar->vParts,0)) );
-        }
-    }
-    // remove partitions
-    Llb_Nonlin4RemovePart( p, pPart1 );
-    Llb_Nonlin4RemovePart( p, pPart2 );
-    // remove other variables
-if ( fVerbose )
-Llb_Nonlin4Print( p );
-    Vec_PtrForEachEntry( Llb_Prt_t *, vSingles, pTemp, i )
-    {
-if ( fVerbose )
-printf( "Updating partitiong %d with singlton vars.\n", pTemp->iPart );
-        Llb_Nonlin4Quantify1( p, pTemp );
-    }
-if ( fVerbose )
-Llb_Nonlin4Print( p );
-    Vec_PtrFree( vSingles );
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Computes volume of the cut.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_Nonlin4CutNodes_rec( Aig_Man_t * p, Aig_Obj_t * pObj, Vec_Ptr_t * vNodes )
-{
-    if ( Aig_ObjIsTravIdCurrent(p, pObj) )
-        return;
-    Aig_ObjSetTravIdCurrent(p, pObj);
-    if ( Saig_ObjIsLi(p, pObj) )
-    {
-        Llb_Nonlin4CutNodes_rec(p, Aig_ObjFanin0(pObj), vNodes);
-        return;
-    }
-    if ( Aig_ObjIsConst1(pObj) )
-        return;
-    assert( Aig_ObjIsNode(pObj) );
-    Llb_Nonlin4CutNodes_rec(p, Aig_ObjFanin0(pObj), vNodes);
-    Llb_Nonlin4CutNodes_rec(p, Aig_ObjFanin1(pObj), vNodes);
-    Vec_PtrPush( vNodes, pObj );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Computes volume of the cut.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Ptr_t * Llb_Nonlin4CutNodes( Aig_Man_t * p, Vec_Ptr_t * vLower, Vec_Ptr_t * vUpper )
-{
-    Vec_Ptr_t * vNodes;
-    Aig_Obj_t * pObj;
-    int i;
-    // mark the lower cut with the traversal ID
-    Aig_ManIncrementTravId(p);
-    Vec_PtrForEachEntry( Aig_Obj_t *, vLower, pObj, i )
-        Aig_ObjSetTravIdCurrent( p, pObj );
-    // count the upper cut
-    vNodes = Vec_PtrAlloc( 100 );
-    Vec_PtrForEachEntry( Aig_Obj_t *, vUpper, pObj, i )
-        Llb_Nonlin4CutNodes_rec( p, pObj, vNodes );
-    return vNodes;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Starts non-linear quantification scheduling.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_Nonlin4AddPair( Llb_Mgr_t * p, int iPart, int iVar )
-{
-    if ( p->pVars[iVar] == NULL )
-    {
-        p->pVars[iVar] = ABC_CALLOC( Llb_Var_t, 1 );
-        p->pVars[iVar]->iVar   = iVar;
-        p->pVars[iVar]->nScore = 0;
-        p->pVars[iVar]->vParts = Vec_IntAlloc( 8 );
-    }
-    Vec_IntPush( p->pVars[iVar]->vParts, iPart );
-    Vec_IntPush( p->pParts[iPart]->vVars, iVar );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Starts non-linear quantification scheduling.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_Nonlin4AddPartition( Llb_Mgr_t * p, int i, DdNode * bFunc )
-{
-    int k, nSuppSize;
-    assert( !Cudd_IsConstant(bFunc) );
-//printf( "Creating init %d\n", i );
-    // create partition
-    p->pParts[i] = ABC_CALLOC( Llb_Prt_t, 1 );
-    p->pParts[i]->iPart = i;
-    p->pParts[i]->bFunc = bFunc;  Cudd_Ref( bFunc );
-    p->pParts[i]->vVars = Vec_IntAlloc( 8 );
-    // add support dependencies
-    nSuppSize = 0;
-    Extra_SupportArray( p->dd, bFunc, p->pSupp );
-    for ( k = 0; k < p->nVars; k++ )
-    {
-        nSuppSize += p->pSupp[k];
-        if ( p->pSupp[k] && Vec_IntEntry(p->vVars2Q, k) )
-            Llb_Nonlin4AddPair( p, i, k );
-    }
-    p->nSuppMax = Abc_MaxInt( p->nSuppMax, nSuppSize ); 
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Checks that each var appears in at least one partition.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-**********************************************************************/
-void Llb_Nonlin4CheckVars( Llb_Mgr_t * p )
-{
-    Llb_Var_t * pVar;
-    int i;
-    Llb_MgrForEachVar( p, pVar, i )
-        assert( Vec_IntSize(pVar->vParts) > 1 );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Find next partition to quantify]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_Nonlin4NextPartitions( Llb_Mgr_t * p, Llb_Prt_t ** ppPart1, Llb_Prt_t ** ppPart2 )
-{
-    Llb_Var_t * pVar, * pVarBest = NULL;
-    Llb_Prt_t * pPart, * pPart1Best = NULL, * pPart2Best = NULL;
-    int i;
-    Llb_Nonlin4CheckVars( p );
-    // find variable with minimum score
-    Llb_MgrForEachVar( p, pVar, i )
-    {
-        if ( p->nSizeMax && pVar->nScore > p->nSizeMax )
-            continue;
-//        if ( pVarBest == NULL || Vec_IntSize(pVarBest->vParts) * pVarBest->nScore > Vec_IntSize(pVar->vParts) * pVar->nScore )
-        if ( pVarBest == NULL || pVarBest->nScore > pVar->nScore )
-            pVarBest = pVar;
-//        printf( "%d ", pVar->nScore );
-    }
-//printf( "\n" );
-    if ( pVarBest == NULL )
-        return 0;
-    // find two partitions with minimum size
-    Llb_VarForEachPart( p, pVarBest, pPart, i )
-    {
-        if ( pPart1Best == NULL )
-            pPart1Best = pPart;
-        else if ( pPart2Best == NULL )
-            pPart2Best = pPart;
-        else if ( pPart1Best->nSize > pPart->nSize || pPart2Best->nSize > pPart->nSize )
-        {
-            if ( pPart1Best->nSize > pPart2Best->nSize )
-                pPart1Best = pPart;
-            else
-                pPart2Best = pPart;
-        }
-    }
-//printf( "Selecting %d and parts %d and %d\n", pVarBest->iVar, pPart1Best->nSize, pPart2Best->nSize );
-//Extra_bddPrintSupport( p->dd, pPart1Best->bFunc ); printf( "\n" );
-//Extra_bddPrintSupport( p->dd, pPart2Best->bFunc ); printf( "\n" );
-
-    *ppPart1 = pPart1Best;
-    *ppPart2 = pPart2Best;
-    return 1; 
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Recomputes scores after variable reordering.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_Nonlin4RecomputeScores( Llb_Mgr_t * p )
-{
-    Llb_Prt_t * pPart;
-    Llb_Var_t * pVar;
-    int i, k;
-    Llb_MgrForEachPart( p, pPart, i )
-        pPart->nSize = Cudd_DagSize(pPart->bFunc);
-    Llb_MgrForEachVar( p, pVar, i )
-    {
-        pVar->nScore = 0;
-        Llb_VarForEachPart( p, pVar, pPart, k )
-            pVar->nScore += pPart->nSize;
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Recomputes scores after variable reordering.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_Nonlin4VerifyScores( Llb_Mgr_t * p )
-{
-    Llb_Prt_t * pPart;
-    Llb_Var_t * pVar;
-    int i, k, nScore;
-    Llb_MgrForEachPart( p, pPart, i )
-        assert( pPart->nSize == Cudd_DagSize(pPart->bFunc) );
-    Llb_MgrForEachVar( p, pVar, i )
-    {
-        nScore = 0;
-        Llb_VarForEachPart( p, pVar, pPart, k )
-            nScore += pPart->nSize;
-        assert( nScore == pVar->nScore );
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Starts non-linear quantification scheduling.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Llb_Mgr_t * Llb_Nonlin4Alloc( DdManager * dd, Vec_Ptr_t * vParts, DdNode * bCurrent, Vec_Int_t * vVars2Q, int nSizeMax )
-{
-    Llb_Mgr_t * p;
-    DdNode * bFunc;
-    int i;
-    p = ABC_CALLOC( Llb_Mgr_t, 1 );
-    p->dd        = dd;
-    p->nSizeMax  = nSizeMax;
-    p->vVars2Q   = vVars2Q;
-    p->nVars     = Cudd_ReadSize(dd);
-    p->iPartFree = Vec_PtrSize(vParts);
-    p->pVars     = ABC_CALLOC( Llb_Var_t *, p->nVars );
-    p->pParts    = ABC_CALLOC( Llb_Prt_t *, 2 * p->iPartFree + 2 );
-    p->pSupp     = ABC_ALLOC( int, Cudd_ReadSize(dd) );
-    // add pairs (refs are consumed inside)
-    Vec_PtrForEachEntry( DdNode *, vParts, bFunc, i )
-        Llb_Nonlin4AddPartition( p, i, bFunc );
-    // add partition
-    if ( bCurrent )
-        Llb_Nonlin4AddPartition( p, p->iPartFree++, bCurrent );
-    return p;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Stops non-linear quantification scheduling.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_Nonlin4Free( Llb_Mgr_t * p )
-{
-    Llb_Prt_t * pPart;
-    Llb_Var_t * pVar;
-    int i;
-    Llb_MgrForEachVar( p, pVar, i )
-        Llb_Nonlin4RemoveVar( p, pVar );
-    Llb_MgrForEachPart( p, pPart, i )
-        Llb_Nonlin4RemovePart( p, pPart );
-    ABC_FREE( p->pVars );
-    ABC_FREE( p->pParts );
-    ABC_FREE( p->pSupp );
-    ABC_FREE( p );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb_Nonlin4Image( DdManager * dd, Vec_Ptr_t * vParts, DdNode * bCurrent, Vec_Int_t * vVars2Q )
-{
-    Llb_Prt_t * pPart, * pPart1, * pPart2;
-    Llb_Mgr_t * p;
-    DdNode * bFunc, * bTemp;
-    int i, nReorders;
-    // start the manager
-    p = Llb_Nonlin4Alloc( dd, vParts, bCurrent, vVars2Q, 0 );
-    // remove singles
-    Llb_MgrForEachPart( p, pPart, i )
-        if ( Llb_Nonlin4HasSingletonVars(p, pPart) )
-            Llb_Nonlin4Quantify1( p, pPart );
-    // compute scores
-    Llb_Nonlin4RecomputeScores( p );
-    // iteratively quantify variables
-    while ( Llb_Nonlin4NextPartitions(p, &pPart1, &pPart2) )
-    {
-        nReorders = Cudd_ReadReorderings(dd);
-        if ( !Llb_Nonlin4Quantify2( p, pPart1, pPart2 ) )
-        {
-            Llb_Nonlin4Free( p );
-            return NULL;
-        }
-        if ( nReorders < Cudd_ReadReorderings(dd) )
-            Llb_Nonlin4RecomputeScores( p );
-//        else
-//            Llb_Nonlin4VerifyScores( p );
-    }
-    // load partitions
-    bFunc = Cudd_ReadOne(p->dd);   Cudd_Ref( bFunc );
-    Llb_MgrForEachPart( p, pPart, i )
-    {
-        bFunc = Cudd_bddAnd( p->dd, bTemp = bFunc, pPart->bFunc );   Cudd_Ref( bFunc );
-        Cudd_RecursiveDeref( p->dd, bTemp );
-    }
-//    nSuppMax = p->nSuppMax;
-    Llb_Nonlin4Free( p );
-//printf( "\n" );
-    // return
-    Cudd_Deref( bFunc );
-    return bFunc;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Ptr_t * Llb_Nonlin4Group( DdManager * dd, Vec_Ptr_t * vParts, Vec_Int_t * vVars2Q, int nSizeMax )
-{
-    Vec_Ptr_t * vGroups;
-    Llb_Prt_t * pPart, * pPart1, * pPart2;
-    Llb_Mgr_t * p;
-    int i, nReorders;//, clk = Abc_Clock();
-    // start the manager
-    p = Llb_Nonlin4Alloc( dd, vParts, NULL, vVars2Q, nSizeMax );
-    // remove singles
-    Llb_MgrForEachPart( p, pPart, i )
-        if ( Llb_Nonlin4HasSingletonVars(p, pPart) )
-            Llb_Nonlin4Quantify1( p, pPart );
-    // compute scores
-    Llb_Nonlin4RecomputeScores( p );
-    // iteratively quantify variables
-    while ( Llb_Nonlin4NextPartitions(p, &pPart1, &pPart2) )
-    {
-        nReorders = Cudd_ReadReorderings(dd);
-        if ( !Llb_Nonlin4Quantify2( p, pPart1, pPart2 ) )
-        {
-            Llb_Nonlin4Free( p );
-            return NULL;
-        }
-        if ( nReorders < Cudd_ReadReorderings(dd) )
-            Llb_Nonlin4RecomputeScores( p );
-//        else
-//            Llb_Nonlin4VerifyScores( p );
-    }
-    // load partitions
-    vGroups = Vec_PtrAlloc( 1000 );
-    Llb_MgrForEachPart( p, pPart, i )
-    {
-//printf( "Iteration %d ", pPart->iPart );
-        if ( Cudd_IsConstant(pPart->bFunc) )
-        {
-//printf( "Constant\n" );
-            assert( !Cudd_IsComplement(pPart->bFunc) );
-            continue;
-        }
-//printf( "\n" );
-        Vec_PtrPush( vGroups, pPart->bFunc );
-        Cudd_Ref( pPart->bFunc );
-//printf( "Part %d  ", pPart->iPart );
-//Extra_bddPrintSupport( p->dd, pPart->bFunc ); printf( "\n" );
-    }
-    Llb_Nonlin4Free( p );
-//Abc_PrintTime( 1, "Reparametrization time", Abc_Clock() - clk );
-    return vGroups;
-}
-
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/llb/llb4Map.c b/src/proof/llb/llb4Map.c
deleted file mode 100644
index 4487ce25..00000000
--- a/src/proof/llb/llb4Map.c
+++ /dev/null
@@ -1,123 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [llb2Map.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD based reachability.]
-
-  Synopsis    [Non-linear quantification scheduling.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: llb2Map.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "llbInt.h"
-#include "base/abc/abc.h"
-#include "map/if/if.h"
-
-ABC_NAMESPACE_IMPL_START
- 
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Returns internal nodes used in the mapping.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Int_t * Llb_AigMap( Aig_Man_t * pAig, int nLutSize, int nLutMin )
-{
-    extern Abc_Ntk_t * Abc_NtkFromAigPhase( Aig_Man_t * pMan );
-    extern If_Man_t *  Abc_NtkToIf( Abc_Ntk_t * pNtk, If_Par_t * pPars );
-    extern void        Gia_ManSetIfParsDefault( void * pPars );
-    If_Par_t Pars, * pPars = &Pars;
-    If_Man_t * pIfMan;
-    If_Obj_t * pAnd;
-    Abc_Ntk_t * pNtk;
-    Abc_Obj_t * pNode;
-    Vec_Int_t * vNodes;
-    Aig_Obj_t * pObj;
-    int i;
-
-    // create ABC network
-    pNtk = Abc_NtkFromAigPhase( pAig );
-    assert( Abc_NtkIsStrash(pNtk) );
-
-    // derive mapping parameters
-    Gia_ManSetIfParsDefault( pPars );
-    pPars->nLutSize = nLutSize;
-
-    // get timing information
-    pPars->pTimesArr = Abc_NtkGetCiArrivalFloats(pNtk);
-    pPars->pTimesReq = Abc_NtkGetCoRequiredFloats(pNtk);
-
-    // perform LUT mapping
-    pIfMan = Abc_NtkToIf( pNtk, pPars );    
-    if ( pIfMan == NULL )
-    {
-        Abc_NtkDelete( pNtk );
-        return NULL;
-    }
-    if ( !If_ManPerformMapping( pIfMan ) )
-    {
-        Abc_NtkDelete( pNtk );
-        If_ManStop( pIfMan );
-        return NULL;
-    }
-
-    // mark nodes in the AIG used in the mapping
-    Aig_ManCleanMarkA( pAig );
-    Aig_ManForEachNode( pAig, pObj, i )
-    {
-        pNode = (Abc_Obj_t *)pObj->pData;
-        if ( pNode == NULL )
-            continue;
-        pAnd = (If_Obj_t *)pNode->pCopy;
-        if ( pAnd == NULL )
-            continue;
-        if ( pAnd->nRefs > 0 && (int)If_ObjCutBest(pAnd)->nLeaves >= nLutMin )
-            pObj->fMarkA = 1;
-    }
-    Abc_NtkDelete( pNtk );
-    If_ManStop( pIfMan );
-
-    // unmark flop drivers
-    Saig_ManForEachLi( pAig, pObj, i )
-        Aig_ObjFanin0(pObj)->fMarkA = 0;
-
-    // collect mapping
-    vNodes = Vec_IntAlloc( 100 );
-    Aig_ManForEachNode( pAig, pObj, i )
-        if ( pObj->fMarkA )
-            Vec_IntPush( vNodes, Aig_ObjId(pObj) );
-    Aig_ManCleanMarkA( pAig );
-    return vNodes;
-}
-
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/llb/llb4Nonlin.c b/src/proof/llb/llb4Nonlin.c
deleted file mode 100644
index a9421358..00000000
--- a/src/proof/llb/llb4Nonlin.c
+++ /dev/null
@@ -1,1185 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [llb2Nonlin.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD based reachability.]
-
-  Synopsis    [Non-linear quantification scheduling.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: llb2Nonlin.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "llbInt.h"
-#include "base/abc/abc.h"
-#include "aig/gia/giaAig.h"
-
-ABC_NAMESPACE_IMPL_START
- 
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-typedef struct Llb_Mnx_t_ Llb_Mnx_t;
-struct Llb_Mnx_t_
-{
-    // user info
-    Aig_Man_t *     pAig;           // AIG manager
-    Gia_ParLlb_t *  pPars;          // parameters
-
-    // intermediate BDDs
-    DdManager *     dd;             // BDD manager
-    DdNode *        bBad;           // bad states in terms of CIs
-    DdNode *        bReached;       // reached states 
-    DdNode *        bCurrent;       // from states
-    DdNode *        bNext;          // to states
-    Vec_Ptr_t *     vRings;         // onion rings in ddR
-    Vec_Ptr_t *     vRoots;         // BDDs for partitions
-
-    // structural info
-    Vec_Int_t *     vOrder;         // for each object ID, its BDD variable number or -1
-    Vec_Int_t *     vVars2Q;        // 1 if variable is quantifiable; 0 othervise
-
-    abctime         timeImage;
-    abctime         timeRemap;
-    abctime         timeReo;
-    abctime         timeOther;
-    abctime         timeTotal;
-};
-
-//extern int timeBuild, timeAndEx, timeOther;
-//extern int nSuppMax;
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
- 
-/**Function*************************************************************
-
-  Synopsis    [Computes bad in working manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb_Nonlin4ComputeBad( DdManager * dd, Aig_Man_t * pAig, Vec_Int_t * vOrder )
-{
-    Vec_Ptr_t * vNodes;
-    DdNode * bBdd, * bBdd0, * bBdd1, * bTemp, * bResult, * bCube;
-    Aig_Obj_t * pObj;
-    int i;
-    Aig_ManCleanData( pAig );
-    // assign elementary variables
-    Aig_ManConst1(pAig)->pData = Cudd_ReadOne(dd); 
-    Aig_ManForEachCi( pAig, pObj, i )
-        pObj->pData = Cudd_bddIthVar( dd, Llb_ObjBddVar(vOrder, pObj) );
-    // compute internal nodes
-    vNodes = Aig_ManDfsNodes( pAig, (Aig_Obj_t **)Vec_PtrArray(pAig->vCos), Saig_ManPoNum(pAig) );
-    Vec_PtrForEachEntry( Aig_Obj_t *, vNodes, pObj, i )
-    {
-        if ( !Aig_ObjIsNode(pObj) )
-            continue;
-        bBdd0 = Cudd_NotCond( (DdNode *)Aig_ObjFanin0(pObj)->pData, Aig_ObjFaninC0(pObj) );
-        bBdd1 = Cudd_NotCond( (DdNode *)Aig_ObjFanin1(pObj)->pData, Aig_ObjFaninC1(pObj) );
-        bBdd  = Cudd_bddAnd( dd, bBdd0, bBdd1 );
-        if ( bBdd == NULL )
-        {
-            Vec_PtrForEachEntry( Aig_Obj_t *, vNodes, pObj, i )
-                if ( Aig_ObjIsNode(pObj) && pObj->pData != NULL )
-                    Cudd_RecursiveDeref( dd, (DdNode *)pObj->pData );
-            Vec_PtrFree( vNodes );
-            return NULL;
-        }
-        Cudd_Ref( bBdd );
-        pObj->pData = bBdd;
-    }
-    // quantify PIs of each PO
-    bResult = Cudd_ReadLogicZero( dd );  Cudd_Ref( bResult );
-    Saig_ManForEachPo( pAig, pObj, i )
-    {
-        bBdd0   = Cudd_NotCond( (DdNode *)Aig_ObjFanin0(pObj)->pData, Aig_ObjFaninC0(pObj) );
-        bResult = Cudd_bddOr( dd, bTemp = bResult, bBdd0 );     
-        if ( bResult == NULL )
-        {
-            Cudd_RecursiveDeref( dd, bTemp );
-            break;
-        }
-        Cudd_Ref( bResult );
-        Cudd_RecursiveDeref( dd, bTemp );
-    }
-    // deref
-    Vec_PtrForEachEntry( Aig_Obj_t *, vNodes, pObj, i )
-        if ( Aig_ObjIsNode(pObj) && pObj->pData != NULL )
-            Cudd_RecursiveDeref( dd, (DdNode *)pObj->pData );
-    Vec_PtrFree( vNodes );
-    if ( bResult )
-    {
-        bCube = Cudd_ReadOne(dd);  Cudd_Ref( bCube );
-        Saig_ManForEachPi( pAig, pObj, i )
-        {
-            bCube = Cudd_bddAnd( dd, bTemp = bCube, (DdNode *)pObj->pData );  
-            if ( bCube == NULL )
-            {
-                Cudd_RecursiveDeref( dd, bTemp );
-                Cudd_RecursiveDeref( dd, bResult );
-                bResult = NULL;
-                break;
-            }
-            Cudd_Ref( bCube );
-            Cudd_RecursiveDeref( dd, bTemp );
-        }
-        if ( bResult != NULL )
-        {
-            bResult = Cudd_bddExistAbstract( dd, bTemp = bResult, bCube );  Cudd_Ref( bResult );
-            Cudd_RecursiveDeref( dd, bTemp );
-            Cudd_RecursiveDeref( dd, bCube );
-            Cudd_Deref( bResult );
-        }
-    }
-//if ( bResult )
-//printf( "Bad state = %d.\n", Cudd_DagSize(bResult) );
-    return bResult;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Derives BDDs for the partitions.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Ptr_t * Llb_Nonlin4DerivePartitions( DdManager * dd, Aig_Man_t * pAig, Vec_Int_t * vOrder )
-{
-    Vec_Ptr_t * vRoots;
-    Aig_Obj_t * pObj;
-    DdNode * bBdd, * bBdd0, * bBdd1, * bPart;
-    int i;
-    Aig_ManCleanData( pAig );
-    // assign elementary variables
-    Aig_ManConst1(pAig)->pData = Cudd_ReadOne(dd); 
-    Aig_ManForEachCi( pAig, pObj, i )
-        pObj->pData = Cudd_bddIthVar( dd, Llb_ObjBddVar(vOrder, pObj) );
-    Aig_ManForEachNode( pAig, pObj, i )
-        if ( Llb_ObjBddVar(vOrder, pObj) >= 0 )
-        {
-            pObj->pData = Cudd_bddIthVar( dd, Llb_ObjBddVar(vOrder, pObj) );
-            Cudd_Ref( (DdNode *)pObj->pData );
-        }
-    Saig_ManForEachLi( pAig, pObj, i )
-        pObj->pData = Cudd_bddIthVar( dd, Llb_ObjBddVar(vOrder, pObj) );
-    // compute intermediate BDDs
-    vRoots = Vec_PtrAlloc( 100 );
-    Aig_ManForEachNode( pAig, pObj, i )
-    {
-        bBdd0 = Cudd_NotCond( (DdNode *)Aig_ObjFanin0(pObj)->pData, Aig_ObjFaninC0(pObj) );
-        bBdd1 = Cudd_NotCond( (DdNode *)Aig_ObjFanin1(pObj)->pData, Aig_ObjFaninC1(pObj) );
-        bBdd  = Cudd_bddAnd( dd, bBdd0, bBdd1 );
-        if ( bBdd == NULL )
-            goto finish;
-        Cudd_Ref( bBdd );
-        if ( pObj->pData == NULL )
-        {
-            pObj->pData = bBdd;
-            continue;
-        }
-        // create new partition
-        bPart = Cudd_bddXnor( dd, (DdNode *)pObj->pData, bBdd );  
-        if ( bPart == NULL )
-            goto finish;
-        Cudd_Ref( bPart );
-        Cudd_RecursiveDeref( dd, bBdd );
-        Vec_PtrPush( vRoots, bPart );
-//printf( "%d ", Cudd_DagSize(bPart) );
-    }
-    // compute register output BDDs
-    Saig_ManForEachLi( pAig, pObj, i )
-    {
-        bBdd0 = Cudd_NotCond( (DdNode *)Aig_ObjFanin0(pObj)->pData, Aig_ObjFaninC0(pObj) );
-        bPart = Cudd_bddXnor( dd, (DdNode *)pObj->pData, bBdd0 );  
-        if ( bPart == NULL )
-            goto finish;
-        Cudd_Ref( bPart );
-        Vec_PtrPush( vRoots, bPart );
-//printf( "%d ", Cudd_DagSize(bPart) );
-    }
-//printf( "\n" );
-    Aig_ManForEachNode( pAig, pObj, i )
-        Cudd_RecursiveDeref( dd, (DdNode *)pObj->pData );
-    return vRoots;
-    // early termination
-finish:
-    Aig_ManForEachNode( pAig, pObj, i )
-        if ( pObj->pData )
-            Cudd_RecursiveDeref( dd, (DdNode *)pObj->pData );
-    Vec_PtrForEachEntry( DdNode *, vRoots, bPart, i )
-        Cudd_RecursiveDeref( dd, bPart );
-    Vec_PtrFree( vRoots );
-    return NULL;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Find simple variable ordering.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Int_t * Llb_Nonlin4CreateOrderSimple( Aig_Man_t * pAig )
-{
-    Vec_Int_t * vOrder;
-    Aig_Obj_t * pObj;
-    int i, Counter = 0;
-    vOrder = Vec_IntStartFull( Aig_ManObjNumMax(pAig) );
-    Aig_ManForEachCi( pAig, pObj, i )
-        Vec_IntWriteEntry( vOrder, Aig_ObjId(pObj), Counter++ );
-    Saig_ManForEachLi( pAig, pObj, i )
-        Vec_IntWriteEntry( vOrder, Aig_ObjId(pObj), Counter++ );
-    return vOrder;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Find good static variable ordering.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_Nonlin4CreateOrder_rec( Aig_Man_t * pAig, Aig_Obj_t * pObj, Vec_Int_t * vOrder, int * pCounter )
-{
-    Aig_Obj_t * pFanin0, * pFanin1;
-    if ( Aig_ObjIsTravIdCurrent(pAig, pObj) )
-        return;
-    Aig_ObjSetTravIdCurrent( pAig, pObj );
-    assert( Llb_ObjBddVar(vOrder, pObj) < 0 );
-    if ( Aig_ObjIsCi(pObj) )
-    {
-//        if ( Saig_ObjIsLo(pAig, pObj) )
-//            Vec_IntWriteEntry( vOrder, Aig_ObjId(Saig_ObjLoToLi(pAig, pObj)), (*pCounter)++ );
-        Vec_IntWriteEntry( vOrder, Aig_ObjId(pObj), (*pCounter)++ );
-        return;
-    }
-    // try fanins with higher level first
-    pFanin0 = Aig_ObjFanin0(pObj);
-    pFanin1 = Aig_ObjFanin1(pObj);
-//    if ( pFanin0->Level > pFanin1->Level || (pFanin0->Level == pFanin1->Level && pFanin0->Id < pFanin1->Id) )
-    if ( pFanin0->Level > pFanin1->Level )
-    {
-        Llb_Nonlin4CreateOrder_rec( pAig, pFanin0, vOrder, pCounter );
-        Llb_Nonlin4CreateOrder_rec( pAig, pFanin1, vOrder, pCounter );
-    }
-    else
-    {
-        Llb_Nonlin4CreateOrder_rec( pAig, pFanin1, vOrder, pCounter );
-        Llb_Nonlin4CreateOrder_rec( pAig, pFanin0, vOrder, pCounter );
-    }
-    if ( pObj->fMarkA )
-        Vec_IntWriteEntry( vOrder, Aig_ObjId(pObj), (*pCounter)++ );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Collect nodes with the given fanout count.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Int_t * Llb_Nonlin4CollectHighRefNodes( Aig_Man_t * pAig, int nFans )
-{
-    Vec_Int_t * vNodes;
-    Aig_Obj_t * pObj;
-    int i;
-    Aig_ManCleanMarkA( pAig );
-    Aig_ManForEachNode( pAig, pObj, i )
-        if ( Aig_ObjRefs(pObj) >= nFans )
-            pObj->fMarkA = 1;
-    // unmark flop drivers
-    Saig_ManForEachLi( pAig, pObj, i )
-        Aig_ObjFanin0(pObj)->fMarkA = 0;
-    // collect mapping
-    vNodes = Vec_IntAlloc( 100 );
-    Aig_ManForEachNode( pAig, pObj, i )
-        if ( pObj->fMarkA )
-            Vec_IntPush( vNodes, Aig_ObjId(pObj) );
-    Aig_ManCleanMarkA( pAig );
-    return vNodes;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Find good static variable ordering.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Int_t * Llb_Nonlin4CreateOrder( Aig_Man_t * pAig )
-{
-    Vec_Int_t * vNodes = NULL;
-    Vec_Int_t * vOrder;
-    Aig_Obj_t * pObj;
-    int i, Counter = 0;
-/*
-    // mark internal nodes to be used
-    Aig_ManCleanMarkA( pAig );
-    vNodes = Llb_Nonlin4CollectHighRefNodes( pAig, 4 );
-    Aig_ManForEachObjVec( vNodes, pAig, pObj, i )
-        pObj->fMarkA = 1;
-printf( "Techmapping added %d pivots.\n", Vec_IntSize(vNodes) );
-*/
-    // collect nodes in the order
-    vOrder = Vec_IntStartFull( Aig_ManObjNumMax(pAig) );
-    Aig_ManIncrementTravId( pAig );
-    Aig_ObjSetTravIdCurrent( pAig, Aig_ManConst1(pAig) );
-    Saig_ManForEachLi( pAig, pObj, i )
-    {
-        Vec_IntWriteEntry( vOrder, Aig_ObjId(pObj), Counter++ );
-        Llb_Nonlin4CreateOrder_rec( pAig, Aig_ObjFanin0(pObj), vOrder, &Counter );
-    }
-    Aig_ManForEachCi( pAig, pObj, i )
-        if ( Llb_ObjBddVar(vOrder, pObj) < 0 )
-        {
-//            if ( Saig_ObjIsLo(pAig, pObj) )
-//                Vec_IntWriteEntry( vOrder, Aig_ObjId(Saig_ObjLoToLi(pAig, pObj)), Counter++ );
-            Vec_IntWriteEntry( vOrder, Aig_ObjId(pObj), Counter++ );
-        }
-    assert( Counter <= Aig_ManCiNum(pAig) + Aig_ManRegNum(pAig) + (vNodes?Vec_IntSize(vNodes):0) );
-    Aig_ManCleanMarkA( pAig );
-    Vec_IntFreeP( &vNodes );
-    return vOrder;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Creates quantifiable varaibles for both types of traversal.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Int_t * Llb_Nonlin4CreateVars2Q( DdManager * dd, Aig_Man_t * pAig, Vec_Int_t * vOrder, int fBackward )
-{
-    Vec_Int_t * vVars2Q;
-    Aig_Obj_t * pObjLi, * pObjLo;
-    int i;
-    vVars2Q = Vec_IntAlloc( 0 );
-    Vec_IntFill( vVars2Q, Cudd_ReadSize(dd), 1 );
-    Saig_ManForEachLiLo( pAig, pObjLi, pObjLo, i )
-        Vec_IntWriteEntry( vVars2Q, Llb_ObjBddVar(vOrder, fBackward ? pObjLo : pObjLi), 0 );
-    return vVars2Q;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Compute initial state in terms of current state variables.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_Nonlin4SetupVarMap( DdManager * dd, Aig_Man_t * pAig, Vec_Int_t * vOrder )
-{
-    DdNode ** pVarsX, ** pVarsY;
-    Aig_Obj_t * pObjLo, * pObjLi;
-    int i;
-    pVarsX = ABC_ALLOC( DdNode *, Cudd_ReadSize(dd) );
-    pVarsY = ABC_ALLOC( DdNode *, Cudd_ReadSize(dd) );
-    Saig_ManForEachLiLo( pAig, pObjLo, pObjLi, i )
-    {
-        assert( Llb_ObjBddVar(vOrder, pObjLo) >= 0 );
-        assert( Llb_ObjBddVar(vOrder, pObjLi) >= 0 );
-        pVarsX[i] = Cudd_bddIthVar( dd, Llb_ObjBddVar(vOrder, pObjLo) );
-        pVarsY[i] = Cudd_bddIthVar( dd, Llb_ObjBddVar(vOrder, pObjLi) );
-    }
-    Cudd_SetVarMap( dd, pVarsX, pVarsY, Aig_ManRegNum(pAig) );
-    ABC_FREE( pVarsX );
-    ABC_FREE( pVarsY );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Compute initial state in terms of current state variables.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb_Nonlin4ComputeInitState( DdManager * dd, Aig_Man_t * pAig, Vec_Int_t * vOrder, int fBackward )
-{
-    Aig_Obj_t * pObjLi, * pObjLo;
-    DdNode * bRes, * bVar, * bTemp;
-    int i;
-    abctime TimeStop;
-    TimeStop = dd->TimeStop;  dd->TimeStop = 0;
-    bRes = Cudd_ReadOne( dd );   Cudd_Ref( bRes );
-    Saig_ManForEachLiLo( pAig, pObjLi, pObjLo, i )
-    {
-        bVar = Cudd_bddIthVar( dd, Llb_ObjBddVar(vOrder, fBackward? pObjLi : pObjLo) );
-        bRes = Cudd_bddAnd( dd, bTemp = bRes, Cudd_Not(bVar) );  Cudd_Ref( bRes );
-        Cudd_RecursiveDeref( dd, bTemp );
-    }
-    Cudd_Deref( bRes );
-    dd->TimeStop = TimeStop;
-    return bRes;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Compute initial state in terms of current state variables.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb_Nonlin4ComputeCube( DdManager * dd, Aig_Man_t * pAig, Vec_Int_t * vOrder, char * pValues, int Flag )
-{
-    Aig_Obj_t * pObjLo, * pObjLi, * pObjTemp;
-    DdNode * bRes, * bVar, * bTemp;
-    int i;
-    abctime TimeStop;
-    TimeStop = dd->TimeStop;  dd->TimeStop = 0;
-    bRes = Cudd_ReadOne( dd );   Cudd_Ref( bRes );
-    Saig_ManForEachLiLo( pAig, pObjLi, pObjLo, i )
-    {
-        if ( Flag )
-            pObjTemp = pObjLo, pObjLo = pObjLi, pObjLi = pObjTemp;
-        // get the correspoding flop input variable
-        bVar = Cudd_bddIthVar( dd, Llb_ObjBddVar(vOrder, pObjLi) );
-        if ( pValues[Llb_ObjBddVar(vOrder, pObjLo)] != 1 )
-            bVar = Cudd_Not(bVar);
-        // create cube
-        bRes = Cudd_bddAnd( dd, bTemp = bRes, bVar );  Cudd_Ref( bRes );
-        Cudd_RecursiveDeref( dd, bTemp );
-    }
-    Cudd_Deref( bRes );
-    dd->TimeStop = TimeStop;
-    return bRes;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Compute initial state in terms of current state variables.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_Nonlin4RecordState( Aig_Man_t * pAig, Vec_Int_t * vOrder, unsigned * pState, char * pValues, int fBackward )
-{
-    Aig_Obj_t * pObjLo, * pObjLi;
-    int i;
-    Saig_ManForEachLiLo( pAig, pObjLi, pObjLo, i )
-        if ( pValues[Llb_ObjBddVar(vOrder, fBackward? pObjLi : pObjLo)] == 1 )
-            Abc_InfoSetBit( pState, i );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Multiply every partition by the cube.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Ptr_t * Llb_Nonlin4Multiply( DdManager * dd, DdNode * bCube, Vec_Ptr_t * vParts )
-{
-    Vec_Ptr_t * vNew;
-    DdNode * bTemp, * bFunc;
-    int i;
-    vNew = Vec_PtrAlloc( Vec_PtrSize(vParts) );
-    Vec_PtrForEachEntry( DdNode *, vParts, bFunc, i )
-    {
-        bTemp = Cudd_bddAnd( dd, bFunc, bCube );  Cudd_Ref( bTemp );
-        Vec_PtrPush( vNew, bTemp );
-    }
-    return vNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Multiply every partition by the cube.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_Nonlin4Deref( DdManager * dd, Vec_Ptr_t * vParts )
-{
-    DdNode * bFunc;
-    int i;
-    Vec_PtrForEachEntry( DdNode *, vParts, bFunc, i )
-        Cudd_RecursiveDeref( dd, bFunc );
-    Vec_PtrFree( vParts );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Derives counter-example by backward reachability.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Ptr_t * Llb_Nonlin4DeriveCex( Llb_Mnx_t * p, int fBackward, int fVerbose )
-{
-    Vec_Int_t * vVars2Q;
-    Vec_Ptr_t * vStates, * vRootsNew;
-    Aig_Obj_t * pObj;
-    DdNode * bState = NULL, * bImage, * bOneCube, * bRing;
-    int i, v, RetValue;//, clk = Abc_Clock();
-    char * pValues;
-    assert( Vec_PtrSize(p->vRings) > 0 );
-    // disable the timeout
-    p->dd->TimeStop  = 0;
-
-    // start the state set
-    vStates = Vec_PtrAllocSimInfo( Vec_PtrSize(p->vRings), Abc_BitWordNum(Aig_ManRegNum(p->pAig)) );
-    Vec_PtrCleanSimInfo( vStates, 0, Abc_BitWordNum(Aig_ManRegNum(p->pAig)) );
-    if ( fBackward )
-        Vec_PtrReverseOrder( vStates );
-
-    // get the last cube
-    pValues = ABC_ALLOC( char, Cudd_ReadSize(p->dd) );
-    bOneCube = Cudd_bddIntersect( p->dd, (DdNode *)Vec_PtrEntryLast(p->vRings), p->bBad );  Cudd_Ref( bOneCube );
-    RetValue = Cudd_bddPickOneCube( p->dd, bOneCube, pValues );
-    Cudd_RecursiveDeref( p->dd, bOneCube );
-    assert( RetValue );
-
-    // record the cube
-    Llb_Nonlin4RecordState( p->pAig, p->vOrder, (unsigned *)Vec_PtrEntryLast(vStates), pValues, fBackward );
-
-    // write state in terms of NS variables
-    if ( Vec_PtrSize(p->vRings) > 1 )
-    {
-        bState = Llb_Nonlin4ComputeCube( p->dd, p->pAig, p->vOrder, pValues, fBackward );   Cudd_Ref( bState );
-    }
-    // perform backward analysis
-    vVars2Q = Llb_Nonlin4CreateVars2Q( p->dd, p->pAig, p->vOrder, !fBackward );
-    Vec_PtrForEachEntryReverse( DdNode *, p->vRings, bRing, v )
-    { 
-        if ( v == Vec_PtrSize(p->vRings) - 1 )
-            continue;
-
-        // preprocess partitions
-        vRootsNew = Llb_Nonlin4Multiply( p->dd, bState, p->vRoots );
-        Cudd_RecursiveDeref( p->dd, bState );
-
-        // compute the next states
-        bImage = Llb_Nonlin4Image( p->dd, vRootsNew, NULL, vVars2Q ); Cudd_Ref( bImage );
-        Llb_Nonlin4Deref( p->dd, vRootsNew );
-
-        // intersect with the previous set
-        bOneCube = Cudd_bddIntersect( p->dd, bImage, bRing );  Cudd_Ref( bOneCube );
-        Cudd_RecursiveDeref( p->dd, bImage );
-
-        // find any assignment of the BDD
-        RetValue = Cudd_bddPickOneCube( p->dd, bOneCube, pValues );
-        Cudd_RecursiveDeref( p->dd, bOneCube );
-        assert( RetValue );
-
-        // record the cube
-        Llb_Nonlin4RecordState( p->pAig, p->vOrder, (unsigned *)Vec_PtrEntry(vStates, v), pValues, fBackward );
-
-        // check that we get the init state
-        if ( v == 0 )
-        {
-            Saig_ManForEachLo( p->pAig, pObj, i )
-                assert( fBackward || pValues[Llb_ObjBddVar(p->vOrder, pObj)] == 0 );
-            break;
-        } 
-
-        // write state in terms of NS variables
-        bState = Llb_Nonlin4ComputeCube( p->dd, p->pAig, p->vOrder, pValues, fBackward );   Cudd_Ref( bState );
-    }
-    Vec_IntFree( vVars2Q );
-    ABC_FREE( pValues );
-    if ( fBackward )
-        Vec_PtrReverseOrder( vStates );
-//    if ( fVerbose )
-//        Abc_PrintTime( 1, "BDD-based cex generation time", Abc_Clock() - clk );
-    return vStates;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Perform reachability with hints.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_Nonlin4Reachability( Llb_Mnx_t * p )
-{ 
-    DdNode * bAux;
-    int nIters, nBddSizeFr = 0, nBddSizeTo = 0, nBddSizeTo2 = 0;
-    abctime clkTemp, clkIter, clk = Abc_Clock();
-    assert( Aig_ManRegNum(p->pAig) > 0 );
-
-    if ( p->pPars->fBackward )
-    {
-        // create bad state in the ring manager
-        if ( !p->pPars->fSkipOutCheck )
-        {
-            p->bBad = Llb_Nonlin4ComputeInitState( p->dd, p->pAig, p->vOrder, p->pPars->fBackward );  Cudd_Ref( p->bBad );
-        }
-        // create init state
-        if ( p->pPars->fCluster )
-            p->bCurrent = p->dd->bFunc, p->dd->bFunc = NULL; 
-        else
-        {
-            p->bCurrent = Llb_Nonlin4ComputeBad( p->dd, p->pAig, p->vOrder );          
-            if ( p->bCurrent == NULL )
-            {
-                if ( !p->pPars->fSilent )
-                    printf( "Reached timeout (%d seconds) during constructing the bad states.\n", p->pPars->TimeLimit );
-                p->pPars->iFrame = -1;
-                return -1;
-            }
-            Cudd_Ref( p->bCurrent );
-        }
-        // remap into the next states
-        p->bCurrent = Cudd_bddVarMap( p->dd, bAux = p->bCurrent );
-        if ( p->bCurrent == NULL )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached timeout (%d seconds) during remapping bad states.\n",  p->pPars->TimeLimit );
-            Cudd_RecursiveDeref( p->dd, bAux );
-            p->pPars->iFrame = -1;
-            return -1;
-        }
-        Cudd_Ref( p->bCurrent );
-        Cudd_RecursiveDeref( p->dd, bAux );
-    }
-    else
-    {
-        // create bad state in the ring manager
-        if ( !p->pPars->fSkipOutCheck )
-        {
-            if ( p->pPars->fCluster )
-                p->bBad = p->dd->bFunc, p->dd->bFunc = NULL; 
-            else
-            {
-                p->bBad = Llb_Nonlin4ComputeBad( p->dd, p->pAig, p->vOrder );          
-                if ( p->bBad == NULL )
-                {
-                    if ( !p->pPars->fSilent )
-                        printf( "Reached timeout (%d seconds) during constructing the bad states.\n", p->pPars->TimeLimit );
-                    p->pPars->iFrame = -1;
-                    return -1;
-                }
-                Cudd_Ref( p->bBad );
-            }
-        }
-        else if ( p->dd->bFunc )
-            Cudd_RecursiveDeref( p->dd, p->dd->bFunc ), p->dd->bFunc = NULL;
-        // compute the starting set of states
-        p->bCurrent = Llb_Nonlin4ComputeInitState( p->dd, p->pAig, p->vOrder, p->pPars->fBackward );  Cudd_Ref( p->bCurrent );
-    }
-    // perform iterations
-    p->bReached = p->bCurrent; Cudd_Ref( p->bReached );
-    for ( nIters = 0; nIters < p->pPars->nIterMax; nIters++ )
-    { 
-        clkIter = Abc_Clock();
-        // check the runtime limit
-        if ( p->pPars->TimeLimit && Abc_Clock() > p->pPars->TimeTarget )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached timeout (%d seconds) during image computation.\n",  p->pPars->TimeLimit );
-            p->pPars->iFrame = nIters - 1;
-            return -1;
-        }
-
-        // save the onion ring
-        Vec_PtrPush( p->vRings, p->bCurrent );   Cudd_Ref( p->bCurrent );
-
-        // check it for bad states
-        if ( !p->pPars->fSkipOutCheck && !Cudd_bddLeq( p->dd, p->bCurrent, Cudd_Not(p->bBad) ) ) 
-        {
-            Vec_Ptr_t * vStates;
-            assert( p->pAig->pSeqModel == NULL );
-            vStates = Llb_Nonlin4DeriveCex( p, p->pPars->fBackward, p->pPars->fVerbose ); 
-            p->pAig->pSeqModel = Llb4_Nonlin4TransformCex( p->pAig, vStates, -1, p->pPars->fVerbose );
-            Vec_PtrFreeP( &vStates );
-            if ( !p->pPars->fSilent )
-            {
-                Abc_Print( 1, "Output %d of miter \"%s\" was asserted in frame %d.  ", p->pAig->pSeqModel->iPo, p->pAig->pName, nIters );
-                Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
-            }
-            p->pPars->iFrame = nIters - 1;
-            return 0;
-        }
-
-        // compute the next states
-        clkTemp = Abc_Clock();
-        p->bNext = Llb_Nonlin4Image( p->dd, p->vRoots, p->bCurrent, p->vVars2Q );
-        if ( p->bNext == NULL )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached timeout (%d seconds) during image computation in quantification.\n",  p->pPars->TimeLimit );
-            p->pPars->iFrame = nIters - 1;
-            return -1;
-        }
-        Cudd_Ref( p->bNext );
-        p->timeImage += Abc_Clock() - clkTemp;
-
-        // remap into current states
-        clkTemp = Abc_Clock();
-        p->bNext = Cudd_bddVarMap( p->dd, bAux = p->bNext );
-        if ( p->bNext == NULL )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached timeout (%d seconds) during remapping next states.\n",  p->pPars->TimeLimit );
-            Cudd_RecursiveDeref( p->dd, bAux );
-            p->pPars->iFrame = nIters - 1;
-            return -1;
-        }
-        Cudd_Ref( p->bNext );
-        Cudd_RecursiveDeref( p->dd, bAux );
-        p->timeRemap += Abc_Clock() - clkTemp;
-
-        // collect statistics
-        if ( p->pPars->fVerbose )
-        {
-            nBddSizeFr  = Cudd_DagSize( p->bCurrent );
-            nBddSizeTo  = Cudd_DagSize( bAux );
-            nBddSizeTo2 = Cudd_DagSize( p->bNext );
-        }
-        Cudd_RecursiveDeref( p->dd, p->bCurrent ); p->bCurrent = NULL;
-
-        // derive new states
-        p->bCurrent = Cudd_bddAnd( p->dd, p->bNext, Cudd_Not(p->bReached) );     
-        if ( p->bCurrent == NULL )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached timeout (%d seconds) during image computation in transfer 1.\n",  p->pPars->TimeLimit );
-            p->pPars->iFrame = nIters - 1;
-            return -1;
-        }
-        Cudd_Ref( p->bCurrent );
-        Cudd_RecursiveDeref( p->dd, p->bNext ); p->bNext = NULL;
-        if ( Cudd_IsConstant(p->bCurrent) )
-            break;
-/*
-        // reduce BDD size using constrain // Cudd_bddRestrict
-        p->bCurrent = Cudd_bddRestrict( p->dd, bAux = p->bCurrent, Cudd_Not(p->bReached) );   
-        Cudd_Ref( p->bCurrent );
-printf( "Before = %d.  After = %d.\n", Cudd_DagSize(bAux), Cudd_DagSize(p->bCurrent) );
-        Cudd_RecursiveDeref( p->dd, bAux );
-*/
-
-        // add to the reached set
-        p->bReached = Cudd_bddOr( p->dd, bAux = p->bReached, p->bCurrent );                 
-        if ( p->bReached == NULL )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached timeout (%d seconds) during image computation in transfer 1.\n",  p->pPars->TimeLimit );
-            p->pPars->iFrame = nIters - 1;
-            Cudd_RecursiveDeref( p->dd, bAux );  
-            return -1;
-        }
-        Cudd_Ref( p->bReached );
-        Cudd_RecursiveDeref( p->dd, bAux );  
-
-
-        // report the results
-        if ( p->pPars->fVerbose )
-        {
-            printf( "I =%5d : ",   nIters );
-            printf( "Fr =%7d  ",   nBddSizeFr );
-            printf( "ImNs =%7d  ", nBddSizeTo );
-            printf( "ImCs =%7d  ", nBddSizeTo2 );
-            printf( "Rea =%7d   ", Cudd_DagSize(p->bReached) );
-            printf( "(%4d %4d)  ", Cudd_ReadReorderings(p->dd), Cudd_ReadGarbageCollections(p->dd) );
-            Abc_PrintTime( 1, "T", Abc_Clock() - clkIter );
-        }
-/*
-        if ( pPars->fVerbose )
-        {
-            double nMints = Cudd_CountMinterm(p->dd, bReached, Saig_ManRegNum(p->pAig) );
-//            Extra_bddPrint( p->dd, bReached );printf( "\n" );
-            printf( "Reachable states = %.0f. (Ratio = %.4f %%)\n", nMints, 100.0*nMints/pow(2.0, Saig_ManRegNum(p->pAig)) );
-            fflush( stdout ); 
-        }
-*/
-        if ( nIters == p->pPars->nIterMax - 1 )
-        {
-            if ( !p->pPars->fSilent )
-                printf( "Reached limit on the number of timeframes (%d).\n",  p->pPars->nIterMax );
-            p->pPars->iFrame = nIters;
-            return -1;
-        }
-    }
-    
-    // report the stats
-    if ( p->pPars->fVerbose )
-    {
-        double nMints = Cudd_CountMinterm(p->dd, p->bReached, Saig_ManRegNum(p->pAig) );
-        if ( p->bCurrent && Cudd_IsConstant(p->bCurrent) )
-            printf( "Reachability analysis completed after %d frames.\n", nIters );
-        else
-            printf( "Reachability analysis is stopped after %d frames.\n", nIters );
-        printf( "Reachable states = %.0f. (Ratio = %.4f %%)\n", nMints, 100.0*nMints/pow(2.0, Saig_ManRegNum(p->pAig)) );
-        fflush( stdout ); 
-    }
-    if ( p->bCurrent == NULL || !Cudd_IsConstant(p->bCurrent) )
-    {
-        if ( !p->pPars->fSilent )
-            printf( "Verified only for states reachable in %d frames.  ", nIters );
-        p->pPars->iFrame = p->pPars->nIterMax;
-        return -1; // undecided
-    }
-    // report
-    if ( !p->pPars->fSilent )
-        printf( "The miter is proved unreachable after %d iterations.  ", nIters );
-    if ( !p->pPars->fSilent )
-        Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
-    p->pPars->iFrame = nIters - 1;
-    return 1; // unreachable
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Reorders BDDs in the working manager.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_Nonlin4Reorder( DdManager * dd, int fTwice, int fVerbose )
-{
-    abctime clk = Abc_Clock();
-    if ( fVerbose )
-        Abc_Print( 1, "Reordering... Before =%5d. ", Cudd_ReadKeys(dd) - Cudd_ReadDead(dd) );
-    Cudd_ReduceHeap( dd, CUDD_REORDER_SYMM_SIFT, 100 );
-    if ( fVerbose )
-        Abc_Print( 1, "After =%5d. ", Cudd_ReadKeys(dd) - Cudd_ReadDead(dd) );
-    if ( fTwice )
-    {
-        Cudd_ReduceHeap( dd, CUDD_REORDER_SYMM_SIFT, 100 );
-        if ( fVerbose )
-            Abc_Print( 1, "After =%5d. ", Cudd_ReadKeys(dd) - Cudd_ReadDead(dd) );
-    }
-    if ( fVerbose )
-        Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
-}
- 
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Llb_Mnx_t * Llb_MnxStart( Aig_Man_t * pAig, Gia_ParLlb_t * pPars )
-{
-    Llb_Mnx_t * p;
-
-    p = ABC_CALLOC( Llb_Mnx_t, 1 );
-    p->pAig    = pAig;
-    p->pPars   = pPars;
-
-    // compute time to stop
-    p->pPars->TimeTarget = p->pPars->TimeLimit ? p->pPars->TimeLimit * CLOCKS_PER_SEC + Abc_Clock(): 0;
-
-    if ( pPars->fCluster )
-    {
-//        Llb_Nonlin4Cluster( p->pAig, &p->dd, &p->vOrder, &p->vRoots, pPars->nBddMax, pPars->fVerbose );
-//        Cudd_AutodynEnable( p->dd,  CUDD_REORDER_SYMM_SIFT );
-        Llb4_Nonlin4Sweep( p->pAig, pPars->nBddMax, pPars->nClusterMax, &p->dd, &p->vOrder, &p->vRoots, pPars->fVerbose );
-        // set the stop time parameter
-        p->dd->TimeStop  = p->pPars->TimeTarget;
-    }
-    else
-    {
-//    p->vOrder  = Llb_Nonlin4CreateOrderSimple( pAig );
-        p->vOrder  = Llb_Nonlin4CreateOrder( pAig );
-        p->dd      = Cudd_Init( Vec_IntCountPositive(p->vOrder) + 1, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
-        Cudd_AutodynEnable( p->dd,  CUDD_REORDER_SYMM_SIFT );
-        Cudd_SetMaxGrowth( p->dd, 1.05 );
-        // set the stop time parameter
-        p->dd->TimeStop  = p->pPars->TimeTarget;
-        p->vRoots  = Llb_Nonlin4DerivePartitions( p->dd, pAig, p->vOrder );
-    }
-
-    Llb_Nonlin4SetupVarMap( p->dd, pAig, p->vOrder );
-    p->vVars2Q = Llb_Nonlin4CreateVars2Q( p->dd, pAig, p->vOrder, p->pPars->fBackward );
-    p->vRings  = Vec_PtrAlloc( 100 );
-
-    if ( pPars->fReorder )
-        Llb_Nonlin4Reorder( p->dd, 0, 1 );
-    return p;
-}
- 
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_MnxStop( Llb_Mnx_t * p )
-{
-    DdNode * bTemp;
-    int i;
-    if ( p->pPars->fVerbose ) 
-    {
-        p->timeReo = Cudd_ReadReorderingTime(p->dd);
-        p->timeOther = p->timeTotal - p->timeImage - p->timeRemap;
-        ABC_PRTP( "Image    ", p->timeImage, p->timeTotal );
-        ABC_PRTP( "Remap    ", p->timeRemap, p->timeTotal );
-        ABC_PRTP( "Other    ", p->timeOther, p->timeTotal );
-        ABC_PRTP( "TOTAL    ", p->timeTotal, p->timeTotal );
-        ABC_PRTP( "  reo    ", p->timeReo,   p->timeTotal );
-    }
-    // remove BDDs
-    if ( p->bBad )
-        Cudd_RecursiveDeref( p->dd, p->bBad );
-    if ( p->bReached )
-        Cudd_RecursiveDeref( p->dd, p->bReached );
-    if ( p->bCurrent )
-        Cudd_RecursiveDeref( p->dd, p->bCurrent );
-    if ( p->bNext )
-        Cudd_RecursiveDeref( p->dd, p->bNext );
-    if ( p->vRings )
-    Vec_PtrForEachEntry( DdNode *, p->vRings, bTemp, i )
-        Cudd_RecursiveDeref( p->dd, bTemp );
-    if ( p->vRoots )
-    Vec_PtrForEachEntry( DdNode *, p->vRoots, bTemp, i )
-        Cudd_RecursiveDeref( p->dd, bTemp );
-    // remove arrays
-    Vec_PtrFreeP( &p->vRings );
-    Vec_PtrFreeP( &p->vRoots );
-//Cudd_PrintInfo( p->dd, stdout );
-    Extra_StopManager( p->dd );
-    Vec_IntFreeP( &p->vOrder );
-    Vec_IntFreeP( &p->vVars2Q );
-    ABC_FREE( p );
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_MnxCheckNextStateVars( Llb_Mnx_t * p )
-{
-    Aig_Obj_t * pObj;
-    int i, Counter0 = 0, Counter1 = 0;
-    Saig_ManForEachLi( p->pAig, pObj, i )
-        if ( Saig_ObjIsLo(p->pAig, Aig_ObjFanin0(pObj)) )
-        {
-            if ( Aig_ObjFaninC0(pObj) )
-                Counter0++;
-            else
-                Counter1++;
-        }
-    printf( "Total = %d.  Direct LO = %d. Compl LO = %d.\n", Aig_ManRegNum(p->pAig), Counter1, Counter0 );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Finds balanced cut.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb_Nonlin4CoreReach( Aig_Man_t * pAig, Gia_ParLlb_t * pPars )
-{
-    Llb_Mnx_t * pMnn;
-    int RetValue = -1;
-    if ( pPars->fVerbose )
-    Aig_ManPrintStats( pAig );
-    if ( pPars->fCluster && Aig_ManObjNum(pAig) >= (1 << 15) )
-    {
-        printf( "The number of objects is more than 2^15.  Clustering cannot be used.\n" );
-        return RetValue;
-    }
-    {
-        abctime clk = Abc_Clock();
-        pMnn = Llb_MnxStart( pAig, pPars );
-//Llb_MnxCheckNextStateVars( pMnn );
-        if ( !pPars->fSkipReach )
-            RetValue = Llb_Nonlin4Reachability( pMnn );
-        pMnn->timeTotal = Abc_Clock() - clk;
-        Llb_MnxStop( pMnn );
-    }
-    return RetValue;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Takes an AIG and returns an AIG representing reachable states.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Aig_Man_t * Llb_ReachableStates( Aig_Man_t * pAig )
-{
-    extern Aig_Man_t * Abc_NtkToDar( Abc_Ntk_t * pNtk, int fExors, int fRegisters );
-    Vec_Int_t * vPermute;
-    Vec_Ptr_t * vNames;
-    Gia_ParLlb_t Pars, * pPars = &Pars;
-    DdManager * dd;
-    DdNode * bReached;
-    Llb_Mnx_t * pMnn;
-    Abc_Ntk_t * pNtk, * pNtkMuxes;
-    Aig_Obj_t * pObj;
-    int i, RetValue;
-    abctime clk = Abc_Clock();
-
-    // create parameters
-    Llb_ManSetDefaultParams( pPars );
-    pPars->fSkipOutCheck = 1;
-    pPars->fCluster      = 0;
-    pPars->fReorder      = 0;
-    pPars->fSilent       = 1;
-    pPars->nBddMax       = 100;
-    pPars->nClusterMax   = 500;
-
-    // run reachability
-    pMnn = Llb_MnxStart( pAig, pPars );
-    RetValue = Llb_Nonlin4Reachability( pMnn );
-    assert( RetValue == 1 );
-
-    // print BDD
-//    Extra_bddPrint( pMnn->dd, pMnn->bReached ); 
-//    Extra_bddPrintSupport( pMnn->dd, pMnn->bReached ); 
-//    printf( "\n" );
-
-    // collect flop output variables
-    vPermute = Vec_IntStartFull( Cudd_ReadSize(pMnn->dd) );
-    Saig_ManForEachLo( pAig, pObj, i )
-        Vec_IntWriteEntry( vPermute, Llb_ObjBddVar(pMnn->vOrder, pObj), i );
-
-    // transfer the reached state BDD into the new manager
-    dd = Cudd_Init( Saig_ManRegNum(pAig), 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
-    Cudd_AutodynEnable( dd,  CUDD_REORDER_SYMM_SIFT );
-    bReached = Extra_TransferPermute( pMnn->dd, dd, pMnn->bReached, Vec_IntArray(vPermute) );  Cudd_Ref( bReached );
-    Vec_IntFree( vPermute );
-    assert( Cudd_ReadSize(dd) == Saig_ManRegNum(pAig) );
-
-    // quit reachability engine
-    pMnn->timeTotal = Abc_Clock() - clk;
-    Llb_MnxStop( pMnn );
-
-    // derive the network
-    vNames = Abc_NodeGetFakeNames( Saig_ManRegNum(pAig) );
-    pNtk = Abc_NtkDeriveFromBdd( dd, bReached, "reached", vNames );
-    Abc_NodeFreeNames( vNames );
-    Cudd_RecursiveDeref( dd, bReached );
-    Cudd_Quit( dd );
-
-    // convert
-    pNtkMuxes = Abc_NtkBddToMuxes( pNtk );
-    Abc_NtkDelete( pNtk );
-    pNtk = Abc_NtkStrash( pNtkMuxes, 0, 1, 0 );
-    Abc_NtkDelete( pNtkMuxes );
-    pAig = Abc_NtkToDar( pNtk, 0, 0 );
-    Abc_NtkDelete( pNtk );
-    return pAig;
-}
-Gia_Man_t * Llb_ReachableStatesGia( Gia_Man_t * p )
-{
-    Gia_Man_t * pNew;
-    Aig_Man_t * pAig, * pReached;
-    pAig = Gia_ManToAigSimple( p );
-    pReached = Llb_ReachableStates( pAig );
-    Aig_ManStop( pAig );
-    pNew = Gia_ManFromAigSimple( pReached );
-    Aig_ManStop( pReached );
-    return pNew;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/llb/llb4Sweep.c b/src/proof/llb/llb4Sweep.c
deleted file mode 100644
index 6b318572..00000000
--- a/src/proof/llb/llb4Sweep.c
+++ /dev/null
@@ -1,589 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [llb2Sweep.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD based reachability.]
-
-  Synopsis    [Non-linear quantification scheduling.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: llb2Sweep.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "llbInt.h"
-
-ABC_NAMESPACE_IMPL_START
- 
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Find good static variable ordering.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_Nonlin4SweepOrder_rec( Aig_Man_t * pAig, Aig_Obj_t * pObj, Vec_Int_t * vOrder, int * pCounter, int fSaveAll )
-{
-    Aig_Obj_t * pFanin0, * pFanin1;
-    if ( Aig_ObjIsTravIdCurrent(pAig, pObj) )
-        return;
-    Aig_ObjSetTravIdCurrent( pAig, pObj );
-    assert( Llb_ObjBddVar(vOrder, pObj) < 0 );
-    if ( Aig_ObjIsCi(pObj) )
-    {
-        Vec_IntWriteEntry( vOrder, Aig_ObjId(pObj), (*pCounter)++ );
-        return;
-    }
-    // try fanins with higher level first
-    pFanin0 = Aig_ObjFanin0(pObj);
-    pFanin1 = Aig_ObjFanin1(pObj);
-//    if ( pFanin0->Level > pFanin1->Level || (pFanin0->Level == pFanin1->Level && pFanin0->Id < pFanin1->Id) )
-    if ( pFanin0->Level > pFanin1->Level )
-    {
-        Llb_Nonlin4SweepOrder_rec( pAig, pFanin0, vOrder, pCounter, fSaveAll );
-        Llb_Nonlin4SweepOrder_rec( pAig, pFanin1, vOrder, pCounter, fSaveAll );
-    }
-    else
-    {
-        Llb_Nonlin4SweepOrder_rec( pAig, pFanin1, vOrder, pCounter, fSaveAll );
-        Llb_Nonlin4SweepOrder_rec( pAig, pFanin0, vOrder, pCounter, fSaveAll );
-    }
-    if ( fSaveAll || pObj->fMarkA )
-        Vec_IntWriteEntry( vOrder, Aig_ObjId(pObj), (*pCounter)++ );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Find good static variable ordering.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Int_t * Llb_Nonlin4SweepOrder( Aig_Man_t * pAig, int * pCounter, int fSaveAll )
-{
-    Vec_Int_t * vOrder;
-    Aig_Obj_t * pObj;
-    int i, Counter = 0;
-    // collect nodes in the order
-    vOrder = Vec_IntStartFull( Aig_ManObjNumMax(pAig) );
-    Aig_ManIncrementTravId( pAig );
-    Aig_ObjSetTravIdCurrent( pAig, Aig_ManConst1(pAig) );
-    Aig_ManForEachCo( pAig, pObj, i )
-    {
-        Vec_IntWriteEntry( vOrder, Aig_ObjId(pObj), Counter++ );
-        Llb_Nonlin4SweepOrder_rec( pAig, Aig_ObjFanin0(pObj), vOrder, &Counter, fSaveAll );
-    }
-    Aig_ManForEachCi( pAig, pObj, i )
-        if ( Llb_ObjBddVar(vOrder, pObj) < 0 )
-            Vec_IntWriteEntry( vOrder, Aig_ObjId(pObj), Counter++ );
-//    assert( Counter == Aig_ManObjNum(pAig) - 1 ); // no dangling nodes
-    if ( pCounter )
-        *pCounter = Counter - Aig_ManCiNum(pAig) - Aig_ManCoNum(pAig);
-    return vOrder;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Performs BDD sweep on the netlist.]
-
-  Description [Returns AIG with internal cut points labeled with fMarkA.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Llb4_Nonlin4SweepCutpoints( Aig_Man_t * pAig, Vec_Int_t * vOrder, int nBddLimit, int fVerbose )
-{
-    DdManager * dd;
-    DdNode * bFunc0, * bFunc1, * bFunc;
-    Aig_Obj_t * pObj;
-    int i, Counter = 0, Counter1 = 0;
-    dd = Cudd_Init( Aig_ManObjNumMax(pAig), 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
-    // assign elementary variables
-    Aig_ManCleanData( pAig );
-    Aig_ManForEachCi( pAig, pObj, i )
-        pObj->pData = Cudd_bddIthVar( dd, Llb_ObjBddVar(vOrder, pObj) );
-    // sweep internal nodes
-    Aig_ManForEachNode( pAig, pObj, i )
-    {
-/*
-        if ( pObj->nRefs >= 4 )
-        {
-            bFunc = Cudd_bddIthVar( dd, Llb_ObjBddVar(vOrder, pObj) );  Cudd_Ref( bFunc );
-            pObj->pData = bFunc;
-            Counter1++;
-            continue;
-        }
-*/
-        bFunc0 = Cudd_NotCond( (DdNode *)Aig_ObjFanin0(pObj)->pData, Aig_ObjFaninC0(pObj) );
-        bFunc1 = Cudd_NotCond( (DdNode *)Aig_ObjFanin1(pObj)->pData, Aig_ObjFaninC1(pObj) );
-        bFunc  = Cudd_bddAnd( dd, bFunc0, bFunc1 );  Cudd_Ref( bFunc );
-        if ( Cudd_DagSize(bFunc) > nBddLimit )
-        {
-//            if ( fVerbose )
-//                printf( "Node %5d : Beg =%5d. ", i, Cudd_DagSize(bFunc) );
-
-            // add cutpoint at a larger one
-            Cudd_RecursiveDeref( dd, bFunc );
-            if ( Cudd_DagSize(bFunc0) >= Cudd_DagSize(bFunc1) )
-            {
-                Cudd_RecursiveDeref( dd, (DdNode *)Aig_ObjFanin0(pObj)->pData );
-                bFunc = Cudd_bddIthVar( dd, Llb_ObjBddVar(vOrder, Aig_ObjFanin0(pObj)) );
-                Aig_ObjFanin0(pObj)->pData = bFunc;  Cudd_Ref( bFunc );
-                Aig_ObjFanin0(pObj)->fMarkA = 1;
-
-//                if ( fVerbose )
-//                    printf( "Ref =%3d  ", Aig_ObjFanin0(pObj)->nRefs );
-            }
-            else
-            {
-                Cudd_RecursiveDeref( dd, (DdNode *)Aig_ObjFanin1(pObj)->pData );
-                bFunc = Cudd_bddIthVar( dd, Llb_ObjBddVar(vOrder, Aig_ObjFanin1(pObj)) );
-                Aig_ObjFanin1(pObj)->pData = bFunc;  Cudd_Ref( bFunc );
-                Aig_ObjFanin1(pObj)->fMarkA = 1;
-
-//                if ( fVerbose )
-//                    printf( "Ref =%3d  ", Aig_ObjFanin1(pObj)->nRefs );
-            }
-            // perform new operation
-            bFunc0 = Cudd_NotCond( (DdNode *)Aig_ObjFanin0(pObj)->pData, Aig_ObjFaninC0(pObj) );
-            bFunc1 = Cudd_NotCond( (DdNode *)Aig_ObjFanin1(pObj)->pData, Aig_ObjFaninC1(pObj) );
-            bFunc  = Cudd_bddAnd( dd, bFunc0, bFunc1 );  Cudd_Ref( bFunc );
-//            assert( Cudd_DagSize(bFunc) <= nBddLimit );
-
-//            if ( fVerbose )
-//                printf( "End =%5d.\n", Cudd_DagSize(bFunc) );
-            Counter++;
-        }
-        pObj->pData = bFunc;
-//printf( "%d ", Cudd_DagSize(bFunc) );
-    }
-//printf( "\n" );
-    // clean up
-    Aig_ManForEachNode( pAig, pObj, i )
-        Cudd_RecursiveDeref( dd, (DdNode *)pObj->pData );
-    Extra_StopManager( dd );
-//    Aig_ManCleanMarkA( pAig );
-    if ( fVerbose )
-    printf( "Added %d cut points.  Used %d high fanout points.\n", Counter, Counter1 );
-    return Counter + Counter1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Derives BDDs for the partitions.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb_Nonlin4SweepPartitions_rec( DdManager * dd, Aig_Obj_t * pObj, Vec_Int_t * vOrder, Vec_Ptr_t * vRoots )
-{
-    DdNode * bBdd, * bBdd0, * bBdd1, * bPart, * vVar;
-    if ( Aig_ObjIsConst1(pObj) )
-        return Cudd_ReadOne(dd); 
-    if ( Aig_ObjIsCi(pObj) )
-        return Cudd_bddIthVar( dd, Llb_ObjBddVar(vOrder, pObj) );
-    if ( pObj->pData )
-        return (DdNode *)pObj->pData;
-    if ( Aig_ObjIsCo(pObj) )
-    {
-        bBdd0 = Cudd_NotCond( Llb_Nonlin4SweepPartitions_rec(dd, Aig_ObjFanin0(pObj), vOrder, vRoots), Aig_ObjFaninC0(pObj) );
-        bPart = Cudd_bddXnor( dd, Cudd_bddIthVar( dd, Llb_ObjBddVar(vOrder, pObj) ), bBdd0 );  Cudd_Ref( bPart );
-        Vec_PtrPush( vRoots, bPart );
-        return NULL;
-    }
-    bBdd0 = Cudd_NotCond( Llb_Nonlin4SweepPartitions_rec(dd, Aig_ObjFanin0(pObj), vOrder, vRoots), Aig_ObjFaninC0(pObj) );
-    bBdd1 = Cudd_NotCond( Llb_Nonlin4SweepPartitions_rec(dd, Aig_ObjFanin1(pObj), vOrder, vRoots), Aig_ObjFaninC1(pObj) );
-    bBdd  = Cudd_bddAnd( dd, bBdd0, bBdd1 );   Cudd_Ref( bBdd );
-    if ( Llb_ObjBddVar(vOrder, pObj) >= 0 )
-    {
-        vVar  = Cudd_bddIthVar( dd, Llb_ObjBddVar(vOrder, pObj) );
-        bPart = Cudd_bddXnor( dd, vVar, bBdd );  Cudd_Ref( bPart );
-        Vec_PtrPush( vRoots, bPart );
-        Cudd_RecursiveDeref( dd, bBdd );
-        bBdd = vVar;  Cudd_Ref( vVar );
-    }
-    pObj->pData = bBdd;
-    return bBdd;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Derives BDDs for the partitions.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Ptr_t * Llb_Nonlin4SweepPartitions( DdManager * dd, Aig_Man_t * pAig, Vec_Int_t * vOrder, int fTransition )
-{
-    Vec_Ptr_t * vRoots;
-    Aig_Obj_t * pObj;
-    int i;
-    Aig_ManCleanData( pAig );
-    vRoots = Vec_PtrAlloc( 100 );
-    if ( fTransition )
-    {
-        Saig_ManForEachLi( pAig, pObj, i )
-            Llb_Nonlin4SweepPartitions_rec( dd, pObj, vOrder, vRoots );
-    }
-    else
-    {
-        Saig_ManForEachPo( pAig, pObj, i )
-            Llb_Nonlin4SweepPartitions_rec( dd, pObj, vOrder, vRoots );
-    }
-    Aig_ManForEachNode( pAig, pObj, i )
-        if ( pObj->pData )
-            Cudd_RecursiveDeref( dd, (DdNode *)pObj->pData );
-    return vRoots;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Get bad state monitor.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Llb4_Nonlin4SweepBadMonitor( Aig_Man_t * pAig, Vec_Int_t * vOrder, DdManager * dd )
-{
-    Aig_Obj_t * pObj;
-    DdNode * bRes, * bVar, * bTemp;
-    int i;
-    abctime TimeStop;
-    TimeStop = dd->TimeStop;  dd->TimeStop = 0;
-    bRes = Cudd_ReadOne( dd );   Cudd_Ref( bRes );
-    Saig_ManForEachPo( pAig, pObj, i )
-    {
-        bVar = Cudd_bddIthVar( dd, Llb_ObjBddVar(vOrder, pObj) );
-        bRes = Cudd_bddAnd( dd, bTemp = bRes, Cudd_Not(bVar) );  Cudd_Ref( bRes );
-        Cudd_RecursiveDeref( dd, bTemp );
-    }
-    Cudd_Deref( bRes );
-    dd->TimeStop = TimeStop;
-    return Cudd_Not(bRes);
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Creates quantifiable variables for both types of traversal.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Int_t * Llb_Nonlin4SweepVars2Q( Aig_Man_t * pAig, Vec_Int_t * vOrder, int fAddLis )
-{
-    Vec_Int_t * vVars2Q;
-    Aig_Obj_t * pObj;
-    int i;
-    vVars2Q = Vec_IntAlloc( 0 );
-    Vec_IntFill( vVars2Q, Aig_ManObjNumMax(pAig), 1 );
-    // add flop outputs
-    Saig_ManForEachLo( pAig, pObj, i )
-        Vec_IntWriteEntry( vVars2Q, Llb_ObjBddVar(vOrder, pObj), 0 );
-    // add flop inputs
-    if ( fAddLis )
-    Saig_ManForEachLi( pAig, pObj, i )
-        Vec_IntWriteEntry( vVars2Q, Llb_ObjBddVar(vOrder, pObj), 0 );
-    return vVars2Q;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Multiply every partition by the cube.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_Nonlin4SweepDeref( DdManager * dd, Vec_Ptr_t * vParts )
-{
-    DdNode * bFunc;
-    int i;
-    Vec_PtrForEachEntry( DdNode *, vParts, bFunc, i )
-        Cudd_RecursiveDeref( dd, bFunc );
-    Vec_PtrFree( vParts );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Multiply every partition by the cube.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_Nonlin4SweepPrint( Vec_Ptr_t * vFuncs )
-{
-    DdNode * bFunc;
-    int i;
-    printf( "(%d) ", Vec_PtrSize(vFuncs) );
-    Vec_PtrForEachEntry( DdNode *, vFuncs, bFunc, i )
-        printf( "%d ", Cudd_DagSize(bFunc) );
-    printf( "\n" );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Computes bad states.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdManager * Llb4_Nonlin4SweepBadStates( Aig_Man_t * pAig, Vec_Int_t * vOrder, int nVars )
-{
-    DdManager * dd;
-    Vec_Ptr_t * vParts;
-    Vec_Int_t * vVars2Q;
-    DdNode * bMonitor, * bImage;
-    // get quantifiable variables
-    vVars2Q = Llb_Nonlin4SweepVars2Q( pAig, vOrder, 0 );
-    // start BDD manager and create partitions 
-    dd = Cudd_Init( nVars, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
-    vParts = Llb_Nonlin4SweepPartitions( dd, pAig, vOrder, 0 );
-//printf( "Outputs: " );
-//Llb_Nonlin4SweepPrint( vParts );
-    // compute image of the partitions
-    bMonitor = Llb4_Nonlin4SweepBadMonitor( pAig, vOrder, dd );  Cudd_Ref( bMonitor );
-    Cudd_AutodynEnable( dd,  CUDD_REORDER_SYMM_SIFT );
-    bImage = Llb_Nonlin4Image( dd, vParts, bMonitor, vVars2Q );  Cudd_Ref( bImage );
-    Cudd_RecursiveDeref( dd, bMonitor );
-    Llb_Nonlin4SweepDeref( dd, vParts );
-    Vec_IntFree( vVars2Q );
-    // save image and return
-    dd->bFunc = bImage;
-    return dd;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Computes clusters.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdManager * Llb4_Nonlin4SweepGroups( Aig_Man_t * pAig, Vec_Int_t * vOrder, int nVars, Vec_Ptr_t ** pvGroups, int nBddLimitClp, int fVerbose )
-{
-    DdManager * dd;
-    Vec_Ptr_t * vParts;
-    Vec_Int_t * vVars2Q;
-    // get quantifiable variables
-    vVars2Q = Llb_Nonlin4SweepVars2Q( pAig, vOrder, 1 );
-    // start BDD manager and create partitions 
-    dd = Cudd_Init( nVars, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
-    vParts = Llb_Nonlin4SweepPartitions( dd, pAig, vOrder, 1 );
-//printf( "Transitions: " );
-//Llb_Nonlin4SweepPrint( vParts );
-    // compute image of the partitions
-
-    Cudd_AutodynEnable( dd,  CUDD_REORDER_SYMM_SIFT );
-    *pvGroups = Llb_Nonlin4Group( dd, vParts, vVars2Q, nBddLimitClp );
-    Llb_Nonlin4SweepDeref( dd, vParts );
-//    *pvGroups = vParts;
-
-if ( fVerbose )
-{
-printf( "Groups: " );
-Llb_Nonlin4SweepPrint( *pvGroups );
-}
-
-    Vec_IntFree( vVars2Q );
-    return dd;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Creates quantifiable variables for both types of traversal.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb_Nonlin4SweepPrintSuppProfile( DdManager * dd, Aig_Man_t * pAig, Vec_Int_t * vOrder, Vec_Ptr_t * vGroups, int fVerbose )
-{
-    Aig_Obj_t * pObj;
-    int i, * pSupp;
-    int nSuppAll = 0, nSuppPi = 0, nSuppPo = 0, nSuppLi = 0, nSuppLo = 0, nSuppAnd = 0;
-
-    pSupp = ABC_CALLOC( int, Cudd_ReadSize(dd) );
-    Extra_VectorSupportArray( dd, (DdNode **)Vec_PtrArray(vGroups), Vec_PtrSize(vGroups), pSupp );
-
-    Aig_ManForEachObj( pAig, pObj, i )
-    {
-        if ( Llb_ObjBddVar(vOrder, pObj) < 0 )
-            continue;
-        // remove variables that do not participate
-        if ( pSupp[Llb_ObjBddVar(vOrder, pObj)] == 0 )
-        {
-            if ( Aig_ObjIsNode(pObj) )
-                Vec_IntWriteEntry( vOrder, Aig_ObjId(pObj), -1 );
-            continue;
-        }
-        nSuppAll++;
-        if ( Saig_ObjIsPi(pAig, pObj) )
-            nSuppPi++;
-        else if ( Saig_ObjIsLo(pAig, pObj) )
-            nSuppLo++;
-        else if ( Saig_ObjIsPo(pAig, pObj) )
-            nSuppPo++;
-        else if ( Saig_ObjIsLi(pAig, pObj) )
-            nSuppLi++;
-        else
-            nSuppAnd++;
-    }
-    ABC_FREE( pSupp );
-
-    if ( fVerbose )
-    {
-    printf( "Groups =%3d  ", Vec_PtrSize(vGroups) );
-    printf( "Variables: all =%4d ",  nSuppAll );
-    printf( "pi =%4d ",  nSuppPi );
-    printf( "po =%4d ",  nSuppPo );
-    printf( "lo =%4d ",  nSuppLo );
-    printf( "li =%4d ",  nSuppLi );
-    printf( "and =%4d",  nSuppAnd );
-    printf( "\n" );
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Performs BDD sweep on the netlist.]
-
-  Description [Returns BDD manager, ordering, clusters, and bad states 
-  inside dd->bFunc.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb4_Nonlin4Sweep( Aig_Man_t * pAig, int nSweepMax, int nClusterMax, DdManager ** pdd, Vec_Int_t ** pvOrder, Vec_Ptr_t ** pvGroups, int fVerbose )
-{
-    DdManager * ddBad, * ddWork;
-    Vec_Ptr_t * vGroups;
-    Vec_Int_t * vOrder;
-    int Counter, nCutPoints;
-
-    // get the original ordering
-    Aig_ManCleanMarkA( pAig );
-    vOrder = Llb_Nonlin4SweepOrder( pAig, &Counter, 1 );
-    assert( Counter == Aig_ManNodeNum(pAig) );
-    // mark the nodes
-    nCutPoints = Llb4_Nonlin4SweepCutpoints( pAig, vOrder, nSweepMax, fVerbose );
-    Vec_IntFree( vOrder );
-    // get better ordering
-    vOrder = Llb_Nonlin4SweepOrder( pAig, &Counter, 0 );
-    assert( Counter == nCutPoints );
-    Aig_ManCleanMarkA( pAig );
-    // compute the BAD states
-    ddBad = Llb4_Nonlin4SweepBadStates( pAig, vOrder, nCutPoints + Aig_ManCiNum(pAig) + Aig_ManCoNum(pAig) );
-    // compute the clusters
-    ddWork = Llb4_Nonlin4SweepGroups( pAig, vOrder, nCutPoints + Aig_ManCiNum(pAig) + Aig_ManCoNum(pAig), &vGroups, nClusterMax, fVerbose );
-    // transfer the result from the Bad manager
-//printf( "Bad before = %d.\n", Cudd_DagSize(ddBad->bFunc) );
-    ddWork->bFunc = Cudd_bddTransfer( ddBad, ddWork, ddBad->bFunc );   Cudd_Ref( ddWork->bFunc );
-    Cudd_RecursiveDeref( ddBad, ddBad->bFunc );  ddBad->bFunc = NULL;
-    Extra_StopManager( ddBad );
-    // update ordering to exclude quantified variables
-//printf( "Bad after = %d.\n", Cudd_DagSize(ddWork->bFunc) );
-
-    Llb_Nonlin4SweepPrintSuppProfile( ddWork, pAig, vOrder, vGroups, fVerbose );
-
-    // return the result
-    *pdd = ddWork;
-    *pvOrder = vOrder;
-    *pvGroups = vGroups;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Performs BDD sweep on the netlist.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Llb4_Nonlin4SweepExperiment( Aig_Man_t * pAig )
-{
-    DdManager * dd;
-    Vec_Int_t * vOrder;
-    Vec_Ptr_t * vGroups;
-    Llb4_Nonlin4Sweep( pAig, 100, 500, &dd, &vOrder, &vGroups, 1 );
-
-    Llb_Nonlin4SweepDeref( dd, vGroups );
-
-    Cudd_RecursiveDeref( dd, dd->bFunc );
-    Extra_StopManager( dd );
-    Vec_IntFree( vOrder );
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-
diff --git a/src/proof/llb/llbInt.h b/src/proof/llb/llbInt.h
deleted file mode 100644
index e2afe59a..00000000
--- a/src/proof/llb/llbInt.h
+++ /dev/null
@@ -1,212 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [llbInt.h]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [BDD-based reachability.]
-
-  Synopsis    [External declarations.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - May 8, 2010.]
-
-  Revision    [$Id: llbInt.h,v 1.00 2010/05/08 00:00:00 alanmi Exp $]
-
-***********************************************************************/
- 
-#ifndef ABC__aig__llb__llbInt_h
-#define ABC__aig__llb__llbInt_h
-
-
-////////////////////////////////////////////////////////////////////////
-///                          INCLUDES                                ///
-////////////////////////////////////////////////////////////////////////
-
-#include <stdio.h>
-#include "aig/aig/aig.h"
-#include "aig/saig/saig.h"
-#include "proof/ssw/ssw.h"
-#include "llb.h"
-
-#include "misc/extra/extraBdd.h"
-
-////////////////////////////////////////////////////////////////////////
-///                         PARAMETERS                               ///
-////////////////////////////////////////////////////////////////////////
-
-ABC_NAMESPACE_HEADER_START
-
-////////////////////////////////////////////////////////////////////////
-///                         BASIC TYPES                              ///
-////////////////////////////////////////////////////////////////////////
-
-typedef struct Llb_Man_t_ Llb_Man_t;
-typedef struct Llb_Mtr_t_ Llb_Mtr_t;
-typedef struct Llb_Grp_t_ Llb_Grp_t;
-
-struct Llb_Man_t_
-{
-    Gia_ParLlb_t *  pPars;          // parameters
-    Aig_Man_t *     pAigGlo;        // initial AIG manager (owned by the caller)
-    Aig_Man_t *     pAig;           // derived AIG manager (created in this package)
-    DdManager *     dd;             // BDD manager
-    DdManager *     ddG;            // BDD manager
-    DdManager *     ddR;            // BDD manager
-    Vec_Int_t *     vObj2Var;       // mapping AIG ObjId into BDD var index
-    Vec_Int_t *     vVar2Obj;       // mapping BDD var index into AIG ObjId
-    Vec_Ptr_t *     vGroups;        // group Id into group pointer
-    Llb_Mtr_t *     pMatrix;        // dependency matrix
-    // image computation
-    Vec_Ptr_t *     vRings;         // onion rings
-    Vec_Int_t *     vVarBegs;       // the first group where the var appears  
-    Vec_Int_t *     vVarEnds;       // the last group where the var appears 
-    // variable mapping
-    Vec_Int_t *     vNs2Glo;        // next state variables into global variables
-    Vec_Int_t *     vCs2Glo;        // next state variables into global variables
-    Vec_Int_t *     vGlo2Cs;        // global variables into current state variables
-    Vec_Int_t *     vGlo2Ns;        // global variables into current state variables
-    // flow computation
-//    Vec_Int_t *     vMem;
-//    Vec_Ptr_t *     vTops;
-//    Vec_Ptr_t *     vBots;
-//    Vec_Ptr_t *     vCuts;
-};
-
-struct Llb_Mtr_t_
-{
-    int             nPis;           // number of primary inputs
-    int             nFfs;           // number of flip-flops
-    int             nRows;          // number of rows
-    int             nCols;          // number of columns
-    int *           pColSums;       // sum of values in a column
-    Llb_Grp_t **    pColGrps;       // group structure for each col
-    int *           pRowSums;       // sum of values in a row
-    char **         pMatrix;        // dependency matrix
-    Llb_Man_t *     pMan;           // manager
-    // partial product
-    char *          pProdVars;      // variables in the partial product
-    int *           pProdNums;      // var counts in the remaining partitions
-};
-
-struct Llb_Grp_t_
-{
-    int             Id;             // group ID
-    Vec_Ptr_t *     vIns;           // input AIG objs
-    Vec_Ptr_t *     vOuts;          // output AIG objs
-    Vec_Ptr_t *     vNodes;         // internal AIG objs
-    Llb_Man_t *     pMan;           // manager
-    Llb_Grp_t *     pPrev;          // previous group
-    Llb_Grp_t *     pNext;          // next group
-};
-
-////////////////////////////////////////////////////////////////////////
-///                      MACRO DEFINITIONS                           ///
-////////////////////////////////////////////////////////////////////////
-
-static inline int Llb_ObjBddVar( Vec_Int_t * vOrder, Aig_Obj_t * pObj ) { return Vec_IntEntry(vOrder, Aig_ObjId(pObj)); }
-
-////////////////////////////////////////////////////////////////////////
-///                    FUNCTION DECLARATIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/*=== llbConstr.c ======================================================*/
-extern Vec_Int_t *     Llb_ManDeriveConstraints( Aig_Man_t * p );
-extern void            Llb_ManPrintEntries( Aig_Man_t * p, Vec_Int_t * vCands );
-/*=== llbCore.c ======================================================*/
-extern int             Llb_ManModelCheckAig( Aig_Man_t * pAigGlo, Gia_ParLlb_t * pPars, Vec_Int_t * vHints, DdManager ** pddGlo );
-/*=== llbCluster.c ======================================================*/
-extern void            Llb_ManCluster( Llb_Mtr_t * p );
-/*=== llbDump.c ======================================================*/
-extern void            Llb_ManDumpReached( DdManager * ddG, DdNode * bReached, char * pModel, char * pFileName );
-/*=== llbFlow.c ======================================================*/
-extern Vec_Ptr_t *     Llb_ManFlow( Aig_Man_t * p, Vec_Ptr_t * vSources, int * pnFlow );
-/*=== llbHint.c ======================================================*/
-extern int             Llb_ManReachabilityWithHints( Llb_Man_t * p );
-extern int             Llb_ManModelCheckAigWithHints( Aig_Man_t * pAigGlo, Gia_ParLlb_t * pPars );
-/*=== llbMan.c =======================================================*/
-extern void            Llb_ManPrepareVarMap( Llb_Man_t * p );
-extern Llb_Man_t *     Llb_ManStart( Aig_Man_t * pAigGlo, Aig_Man_t * pAig, Gia_ParLlb_t *  pPars );
-extern void            Llb_ManStop( Llb_Man_t * p );
-/*=== llbMatrix.c ====================================================*/
-extern void            Llb_MtrVerifyMatrix( Llb_Mtr_t * p );
-extern Llb_Mtr_t *     Llb_MtrCreate( Llb_Man_t * p );
-extern void            Llb_MtrFree( Llb_Mtr_t * p );
-extern void            Llb_MtrPrint( Llb_Mtr_t * p, int fOrder );
-extern void            Llb_MtrPrintMatrixStats( Llb_Mtr_t * p ); 
-/*=== llbPart.c ======================================================*/
-extern Llb_Grp_t *     Llb_ManGroupAlloc( Llb_Man_t * pMan );
-extern void            Llb_ManGroupStop( Llb_Grp_t * p );
-extern void            Llb_ManPrepareGroups( Llb_Man_t * pMan );
-extern Llb_Grp_t *     Llb_ManGroupsCombine( Llb_Grp_t * p1, Llb_Grp_t * p2 );
-extern Llb_Grp_t *     Llb_ManGroupCreateFromCuts( Llb_Man_t * pMan, Vec_Int_t * vCut1, Vec_Int_t * vCut2 );
-extern void            Llb_ManPrepareVarLimits( Llb_Man_t * p );
-/*=== llbPivot.c =====================================================*/
-extern int             Llb_ManTracePaths( Aig_Man_t * p, Aig_Obj_t * pPivot );
-extern Vec_Int_t *     Llb_ManMarkPivotNodes( Aig_Man_t * p, int fUseInternal );
-/*=== llbReach.c =====================================================*/
-extern int             Llb_ManReachability( Llb_Man_t * p, Vec_Int_t * vHints, DdManager ** pddGlo );
-/*=== llbSched.c =====================================================*/
-extern void            Llb_MtrSchedule( Llb_Mtr_t * p );
-
-/*=== llb2Bad.c ======================================================*/
-extern DdNode *        Llb_BddComputeBad( Aig_Man_t * pInit, DdManager * dd, abctime TimeOut );
-extern DdNode *        Llb_BddQuantifyPis( Aig_Man_t * pInit, DdManager * dd, DdNode * bFunc );
-/*=== llb2Core.c ======================================================*/
-extern DdNode *        Llb_CoreComputeCube( DdManager * dd, Vec_Int_t * vVars, int fUseVarIndex, char * pValues );
-extern int             Llb_CoreExperiment( Aig_Man_t * pInit, Aig_Man_t * pAig, Gia_ParLlb_t * pPars, Vec_Ptr_t * vResult, abctime TimeTarget ); 
-/*=== llb2Driver.c ======================================================*/
-extern Vec_Int_t *     Llb_DriverCountRefs( Aig_Man_t * p );
-extern Vec_Int_t *     Llb_DriverCollectNs( Aig_Man_t * pAig, Vec_Int_t * vDriRefs );
-extern Vec_Int_t *     Llb_DriverCollectCs( Aig_Man_t * pAig );
-extern DdNode *        Llb_DriverPhaseCube( Aig_Man_t * pAig, Vec_Int_t * vDriRefs, DdManager * dd );
-extern DdManager *     Llb_DriverLastPartition( Aig_Man_t * p, Vec_Int_t * vVarsNs, abctime TimeTarget );
-/*=== llb2Image.c ======================================================*/
-extern Vec_Ptr_t *     Llb_ImgSupports( Aig_Man_t * p, Vec_Ptr_t * vDdMans, Vec_Int_t * vStart, Vec_Int_t * vStop, int fAddPis, int fVerbose );
-extern void            Llb_ImgSchedule( Vec_Ptr_t * vSupps, Vec_Ptr_t ** pvQuant0, Vec_Ptr_t ** pvQuant1, int fVerbose );
-extern DdManager *     Llb_ImgPartition( Aig_Man_t * p, Vec_Ptr_t * vLower, Vec_Ptr_t * vUpper, abctime TimeTarget );
-extern void            Llb_ImgQuantifyFirst( Aig_Man_t * pAig, Vec_Ptr_t * vDdMans, Vec_Ptr_t * vQuant0, int fVerbose );
-extern void            Llb_ImgQuantifyReset( Vec_Ptr_t * vDdMans );
-extern DdNode *        Llb_ImgComputeImage( Aig_Man_t * pAig, Vec_Ptr_t * vDdMans, DdManager * dd, DdNode * bInit, 
-                           Vec_Ptr_t * vQuant0, Vec_Ptr_t * vQuant1, Vec_Int_t * vDriRefs, 
-                           abctime TimeTarget, int fBackward, int fReorder, int fVerbose );
-
-extern DdManager *     Llb_NonlinImageStart( Aig_Man_t * pAig, Vec_Ptr_t * vLeaves, Vec_Ptr_t * vRoots, int * pVars2Q, int * pOrder, int fFirst, abctime TimeTarget );
-extern DdNode *        Llb_NonlinImageCompute( DdNode * bCurrent, int fReorder, int fDrop, int fVerbose, int * pOrder );
-extern void            Llb_NonlinImageQuit();
-
-/*=== llb3Image.c =======================================================*/
-extern DdNode *        Llb_NonlinImage( Aig_Man_t * pAig, Vec_Ptr_t * vLeaves, Vec_Ptr_t * vRoots, int * pVars2Q, 
-                           DdManager * dd, DdNode * bCurrent, int fReorder, int fVerbose, int * pOrder );
-/*=== llb3Nonlin.c ======================================================*/
-extern DdNode *        Llb_NonlinComputeInitState( Aig_Man_t * pAig, DdManager * dd );
-
-
-/*=== llb4Cex.c =======================================================*/
-extern Abc_Cex_t *     Llb4_Nonlin4TransformCex( Aig_Man_t * pAig, Vec_Ptr_t * vStates, int iCexPo, int fVerbose );
-/*=== llb4Cluster.c =======================================================*/
-//extern void            Llb_Nonlin4Cluster( Aig_Man_t * pAig, DdManager ** pdd, Vec_Int_t ** pvOrder, Vec_Ptr_t ** pvGroups, int nBddMax, int fVerbose );
-/*=== llb4Image.c =======================================================*/
-extern DdNode *        Llb_Nonlin4Image( DdManager * dd, Vec_Ptr_t * vParts, DdNode * bCurrent, Vec_Int_t * vVars2Q );
-extern Vec_Ptr_t *     Llb_Nonlin4Group( DdManager * dd, Vec_Ptr_t * vParts, Vec_Int_t * vVars2Q, int nSizeMax );
-/*=== llb4Map.c =========================================================*/
-//extern Vec_Int_t *     Llb_AigMap( Aig_Man_t * pAig, int nLutSize, int nLutMin );
-/*=== llb4Nonlin.c ======================================================*/
-//extern int             Llb_Nonlin4CoreReach( Aig_Man_t * pAig, Gia_ParLlb_t * pPars );
-/*=== llb4Sweep.c ======================================================*/
-extern void            Llb4_Nonlin4Sweep( Aig_Man_t * pAig, int nSweepMax, int nClusterMax, DdManager ** pdd, Vec_Int_t ** pvOrder, Vec_Ptr_t ** pvGroups, int fVerbose );
- 
-
-ABC_NAMESPACE_HEADER_END
-
-
-
-#endif
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
diff --git a/src/proof/llb/module.make b/src/proof/llb/module.make
deleted file mode 100644
index b08c42af..00000000
--- a/src/proof/llb/module.make
+++ /dev/null
@@ -1,22 +0,0 @@
-SRC +=    src/proof/llb/llb1Cluster.c \
-    src/proof/llb/llb1Constr.c \
-    src/proof/llb/llb1Core.c \
-    src/proof/llb/llb1Group.c \
-    src/proof/llb/llb1Hint.c \
-    src/proof/llb/llb1Man.c \
-    src/proof/llb/llb1Matrix.c \
-    src/proof/llb/llb1Pivot.c \
-    src/proof/llb/llb1Reach.c \
-    src/proof/llb/llb1Sched.c \
-    src/proof/llb/llb2Bad.c \
-    src/proof/llb/llb2Core.c \
-    src/proof/llb/llb2Driver.c \
-    src/proof/llb/llb2Dump.c \
-    src/proof/llb/llb2Flow.c \
-    src/proof/llb/llb2Image.c \
-    src/proof/llb/llb3Image.c \
-    src/proof/llb/llb3Nonlin.c \
-    src/proof/llb/llb4Cex.c \
-    src/proof/llb/llb4Image.c \
-    src/proof/llb/llb4Nonlin.c \
-    src/proof/llb/llb4Sweep.c