ruby_abc 0.0.6 → 0.1.0

data/ext/abc/src/aig/gia/giaDup.c

@@ -1,4791 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [giaDup.c]
-
-  SystemName  [ABC: Logic synthesis and verification system.]
-
-  PackageName [Scalable AIG package.]
-
-  Synopsis    [Duplication procedures.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - June 20, 2005.]
-
-  Revision    [$Id: giaDup.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "gia.h"
-#include "misc/tim/tim.h"
-#include "misc/vec/vecWec.h"
-#include "misc/util/utilTruth.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Removes pointers to the unmarked nodes..]
-
-  Description [Array vLits contains literals of p. At the same time, 
-  each object pObj of p points to a literal of pNew. This procedure
-  remaps literals in array vLits into literals of pNew.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Gia_ManDupRemapLiterals( Vec_Int_t * vLits, Gia_Man_t * p )
-{
-    Gia_Obj_t * pObj;
-    int i, iLit, iLitNew;
-    Vec_IntForEachEntry( vLits, iLit, i )
-    {
-        if ( iLit < 0 )
-            continue;
-        pObj = Gia_ManObj( p, Abc_Lit2Var(iLit) );
-        if ( ~pObj->Value == 0 )
-            iLitNew = -1;
-        else
-            iLitNew = Abc_LitNotCond( pObj->Value, Abc_LitIsCompl(iLit) );
-        Vec_IntWriteEntry( vLits, i, iLitNew );
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Removes pointers to the unmarked nodes..]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Gia_ManDupRemapEquiv( Gia_Man_t * pNew, Gia_Man_t * p )
-{
-    Vec_Int_t * vClass;
-    int i, k, iNode, iRepr, iPrev;
-    if ( p->pReprs == NULL )
-        return;
-    assert( pNew->pReprs == NULL && pNew->pNexts == NULL );
-    // start representatives
-    pNew->pReprs = ABC_CALLOC( Gia_Rpr_t, Gia_ManObjNum(pNew) );
-    for ( i = 0; i < Gia_ManObjNum(pNew); i++ )
-        Gia_ObjSetRepr( pNew, i, GIA_VOID );
-    // iterate over constant candidates
-    Gia_ManForEachConst( p, i )
-        Gia_ObjSetRepr( pNew, Abc_Lit2Var(Gia_ManObj(p, i)->Value), 0 );
-    // iterate over class candidates
-    vClass = Vec_IntAlloc( 100 );
-    Gia_ManForEachClass( p, i )
-    {
-        Vec_IntClear( vClass );
-        Gia_ClassForEachObj( p, i, k )
-            Vec_IntPushUnique( vClass, Abc_Lit2Var(Gia_ManObj(p, k)->Value) );
-        assert( Vec_IntSize( vClass ) > 1 );
-        Vec_IntSort( vClass, 0 );
-        iRepr = iPrev = Vec_IntEntry( vClass, 0 );
-        Vec_IntForEachEntryStart( vClass, iNode, k, 1 )
-        {
-            Gia_ObjSetRepr( pNew, iNode, iRepr );
-            assert( iPrev < iNode );
-            iPrev = iNode;
-        }
-    }
-    Vec_IntFree( vClass );
-    pNew->pNexts = Gia_ManDeriveNexts( pNew );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Remaps combinational inputs when objects are DFS ordered.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Gia_ManDupRemapCis( Gia_Man_t * pNew, Gia_Man_t * p )
-{
-    Gia_Obj_t * pObj, * pObjNew;
-    int i;
-    assert( Vec_IntSize(p->vCis) == Vec_IntSize(pNew->vCis) );
-    Gia_ManForEachCi( p, pObj, i )
-    {
-        assert( Gia_ObjCioId(pObj) == i );
-        pObjNew = Gia_ObjFromLit( pNew, pObj->Value );
-        assert( !Gia_IsComplement(pObjNew) );
-        Vec_IntWriteEntry( pNew->vCis, i, Gia_ObjId(pNew, pObjNew) );
-        Gia_ObjSetCioId( pObjNew, i );
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Remaps combinational outputs when objects are DFS ordered.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Gia_ManDupRemapCos( Gia_Man_t * pNew, Gia_Man_t * p )
-{
-    Gia_Obj_t * pObj, * pObjNew;
-    int i;
-    assert( Vec_IntSize(p->vCos) == Vec_IntSize(pNew->vCos) );
-    Gia_ManForEachCo( p, pObj, i )
-    {
-        assert( Gia_ObjCioId(pObj) == i );
-        pObjNew = Gia_ObjFromLit( pNew, pObj->Value );
-        assert( !Gia_IsComplement(pObjNew) );
-        Vec_IntWriteEntry( pNew->vCos, i, Gia_ObjId(pNew, pObjNew) );
-        Gia_ObjSetCioId( pObjNew, i );
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates the AIG in the DFS order.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Gia_ManDupOrderDfs_rec( Gia_Man_t * pNew, Gia_Man_t * p, Gia_Obj_t * pObj )
-{
-    if ( ~pObj->Value )
-        return pObj->Value;
-    if ( Gia_ObjIsCi(pObj) )
-        return pObj->Value = Gia_ManAppendCi(pNew);
-//    if ( p->pNexts && Gia_ObjNext(p, Gia_ObjId(p, pObj)) )
-//        Gia_ManDupOrderDfs_rec( pNew, p, Gia_ObjNextObj(p, Gia_ObjId(p, pObj)) );
-    Gia_ManDupOrderDfs_rec( pNew, p, Gia_ObjFanin0(pObj) );
-    if ( Gia_ObjIsCo(pObj) )
-        return pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManDupOrderDfs_rec( pNew, p, Gia_ObjFanin1(pObj) );
-    return pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-} 
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates AIG while putting objects in the DFS order.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupOrderDfs( Gia_Man_t * p )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i;
-    Gia_ManFillValue( p );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachCo( p, pObj, i )
-        Gia_ManDupOrderDfs_rec( pNew, p, pObj );
-    Gia_ManForEachCi( p, pObj, i )
-        if ( !~pObj->Value )
-            pObj->Value = Gia_ManAppendCi(pNew);
-    assert( Gia_ManCiNum(pNew) == Gia_ManCiNum(p) );
-    Gia_ManDupRemapCis( pNew, p );
-    Gia_ManDupRemapEquiv( pNew, p );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates AIG while putting objects in the DFS order.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupAbs( Gia_Man_t * p, Vec_Int_t * vMapPpi2Ff, Vec_Int_t * vMapFf2Ppi )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int k, Flop, Used;
-    assert( Vec_IntSize(vMapFf2Ppi) == Vec_IntSize(vMapPpi2Ff) + Vec_IntCountEntry(vMapFf2Ppi, -1) );
-    Gia_ManFillValue( p );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    // create inputs
-    Gia_ManForEachPi( p, pObj, k )
-        pObj->Value = Gia_ManAppendCi(pNew);
-    Vec_IntForEachEntry( vMapPpi2Ff, Flop, k )
-    {
-        pObj = Gia_ManCi( p, Gia_ManPiNum(p) + Flop );
-        pObj->Value = Gia_ManAppendCi(pNew);
-    }
-    Vec_IntForEachEntry( vMapFf2Ppi, Used, Flop )
-    {
-        pObj = Gia_ManCi( p, Gia_ManPiNum(p) + Flop );
-        if ( Used >= 0 )
-        {
-            assert( pObj->Value != ~0 );
-            continue;
-        }
-        assert( pObj->Value == ~0 );
-        pObj->Value = Gia_ManAppendCi(pNew);
-    }
-    Gia_ManForEachCi( p, pObj, k )
-        assert( pObj->Value != ~0 );
-    // create nodes
-    Gia_ManForEachPo( p, pObj, k )
-        Gia_ManDupOrderDfs_rec( pNew, p, Gia_ObjFanin0(pObj) );
-    Vec_IntForEachEntry( vMapFf2Ppi, Used, Flop )
-    {
-        if ( Used >= 0 )
-            continue;
-        pObj = Gia_ManCi( p, Gia_ManPiNum(p) + Flop );
-        pObj = Gia_ObjRoToRi( p, pObj );
-        Gia_ManDupOrderDfs_rec( pNew, p, Gia_ObjFanin0(pObj) );
-    }
-    // create outputs
-    Gia_ManForEachPo( p, pObj, k )
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Vec_IntForEachEntry( vMapFf2Ppi, Used, Flop )
-    {
-        if ( Used >= 0 )
-            continue;
-        pObj = Gia_ManCi( p, Gia_ManPiNum(p) + Flop );
-        pObj = Gia_ObjRoToRi( p, pObj );
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    }
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) - Vec_IntSize(vMapPpi2Ff) );
-    assert( Gia_ManPiNum(pNew) == Gia_ManPiNum(p) + Vec_IntSize(vMapPpi2Ff) );
-    assert( Gia_ManCiNum(pNew) == Gia_ManCiNum(p) );
-    assert( Gia_ManPoNum(pNew) == Gia_ManPoNum(p) );
-    assert( Gia_ManCoNum(pNew) == Gia_ManCoNum(p) - Vec_IntSize(vMapPpi2Ff) );
-    return pNew;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates AIG while putting objects in the DFS order.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupOutputGroup( Gia_Man_t * p, int iOutStart, int iOutStop )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i;
-    Gia_ManFillValue( p );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    for ( i = iOutStart; i < iOutStop; i++ )
-    {
-        pObj = Gia_ManCo( p, i );
-        Gia_ManDupOrderDfs_rec( pNew, p, pObj );
-    }
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates AIG while putting objects in the DFS order.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupOutputVec( Gia_Man_t * p, Vec_Int_t * vOutPres )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i;
-    assert( Gia_ManRegNum(p) == 0 );
-    assert( Gia_ManPoNum(p) == Vec_IntSize(vOutPres) );
-    Gia_ManFillValue( p );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachPi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi(pNew);
-    Gia_ManForEachPo( p, pObj, i )
-        if ( Vec_IntEntry(vOutPres, i) )
-            Gia_ManDupOrderDfs_rec( pNew, p, Gia_ObjFanin0(pObj) );
-    Gia_ManForEachPo( p, pObj, i )
-        if ( Vec_IntEntry(vOutPres, i) )
-            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates AIG while putting objects in the DFS order.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupSelectedOutputs( Gia_Man_t * p, Vec_Int_t * vOutsLeft )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i, iOut;
-    assert( Gia_ManRegNum(p) == 0 );
-    assert( Gia_ManPoNum(p) >= Vec_IntSize(vOutsLeft) );
-    Gia_ManFillValue( p );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachPi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi(pNew);
-    Vec_IntForEachEntry( vOutsLeft, iOut, i )
-        Gia_ManDupOrderDfs_rec( pNew, p, Gia_ObjFanin0(Gia_ManPo(p, iOut)) );
-    Vec_IntForEachEntry( vOutsLeft, iOut, i )
-        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(Gia_ManPo(p, iOut)) );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates the AIG in the DFS order.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Gia_ManDupOrderDfsChoices_rec( Gia_Man_t * pNew, Gia_Man_t * p, Gia_Obj_t * pObj )
-{
-    Gia_Obj_t * pNext;
-    if ( ~pObj->Value )
-        return;
-    assert( Gia_ObjIsAnd(pObj) );
-    pNext = Gia_ObjNextObj( p, Gia_ObjId(p, pObj) );
-    if ( pNext )
-        Gia_ManDupOrderDfsChoices_rec( pNew, p, pNext );
-    Gia_ManDupOrderDfsChoices_rec( pNew, p, Gia_ObjFanin0(pObj) );
-    Gia_ManDupOrderDfsChoices_rec( pNew, p, Gia_ObjFanin1(pObj) );
-    pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    if ( pNext )
-    {
-        pNew->pNexts[Abc_Lit2Var(pObj->Value)] = Abc_Lit2Var( Abc_Lit2Var(pNext->Value) );
-        assert( Abc_Lit2Var(pObj->Value) > Abc_Lit2Var(pNext->Value) );
-    }
-} 
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates AIG while putting objects in the DFS order.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupOrderDfsChoices( Gia_Man_t * p )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i;
-    assert( p->pReprs && p->pNexts );
-    Gia_ManFillValue( p );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    pNew->pNexts = ABC_CALLOC( int, Gia_ManObjNum(p) );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachCi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi(pNew);
-    Gia_ManForEachCo( p, pObj, i )
-    {
-        Gia_ManDupOrderDfsChoices_rec( pNew, p, Gia_ObjFanin0(pObj) );
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    }
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-//    Gia_ManDeriveReprs( pNew );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates AIG while putting objects in the DFS order.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupOrderDfsReverse( Gia_Man_t * p )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i;
-    Gia_ManFillValue( p );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachCoReverse( p, pObj, i )
-        Gia_ManDupOrderDfs_rec( pNew, p, pObj );
-    Gia_ManForEachCi( p, pObj, i )
-        if ( !~pObj->Value )
-            pObj->Value = Gia_ManAppendCi(pNew);
-    assert( Gia_ManCiNum(pNew) == Gia_ManCiNum(p) );
-    Gia_ManDupRemapCis( pNew, p );
-    Gia_ManDupRemapCos( pNew, p );
-    Gia_ManDupRemapEquiv( pNew, p );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates AIG while putting first PIs, then nodes, then POs.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupOrderAiger( Gia_Man_t * p )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i;
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachCi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi(pNew);
-    Gia_ManForEachAnd( p, pObj, i )
-        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    Gia_ManForEachCo( p, pObj, i )
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManDupRemapEquiv( pNew, p );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    assert( Gia_ManIsNormalized(pNew) );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates AIG while putting first PIs, then nodes, then POs.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupOnsetOffset( Gia_Man_t * p )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i;
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachCi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi(pNew);
-    Gia_ManForEachAnd( p, pObj, i )
-        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    Gia_ManForEachCo( p, pObj, i )
-    {
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-        pObj->Value = Gia_ManAppendCo( pNew, Abc_LitNot(Gia_ObjFanin0Copy(pObj)) );
-    }
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates AIG while putting first PIs, then nodes, then POs.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupLastPis( Gia_Man_t * p, int nLastPis )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i;
-    assert( Gia_ManRegNum(p) == 0 );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachCi( p, pObj, i )
-        pObj->Value = (i < Gia_ManCiNum(p) - nLastPis) ? ~0 : Gia_ManAppendCi(pNew);
-    Gia_ManForEachAnd( p, pObj, i )
-        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    Gia_ManForEachCo( p, pObj, i )
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates AIG while complementing the flops.]
-
-  Description [The array of initial state contains the init state
-  for each state bit of the flops in the design.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupFlip( Gia_Man_t * p, int * pInitState )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i;
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachObj1( p, pObj, i )
-    {
-        if ( Gia_ObjIsAnd(pObj) )
-            pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-        else if ( Gia_ObjIsCi(pObj) )
-        {
-            pObj->Value = Gia_ManAppendCi( pNew );
-            if ( Gia_ObjCioId(pObj) >= Gia_ManPiNum(p) )
-                pObj->Value = Abc_LitNotCond( pObj->Value, Abc_InfoHasBit((unsigned *)pInitState, Gia_ObjCioId(pObj) - Gia_ManPiNum(p)) );
-        }
-        else if ( Gia_ObjIsCo(pObj) )
-        {
-            pObj->Value = Gia_ObjFanin0Copy(pObj);
-            if ( Gia_ObjCioId(pObj) >= Gia_ManPoNum(p) )
-                pObj->Value = Abc_LitNotCond( pObj->Value, Abc_InfoHasBit((unsigned *)pInitState, Gia_ObjCioId(pObj) - Gia_ManPoNum(p)) );
-            pObj->Value = Gia_ManAppendCo( pNew, pObj->Value );
-        }
-    }
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    return pNew;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Cycles AIG using random input.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Gia_ManCycle( Gia_Man_t * p, Abc_Cex_t * pCex, int nFrames )
-{
-    Gia_Obj_t * pObj, * pObjRi, * pObjRo;
-    int i, k;
-    Gia_ManRandom( 1 );
-    assert( pCex == NULL || nFrames <= pCex->iFrame );
-    // iterate for the given number of frames
-    for ( i = 0; i < nFrames; i++ )
-    {
-        Gia_ManForEachPi( p, pObj, k )
-            pObj->fMark0 = pCex ? Abc_InfoHasBit(pCex->pData, pCex->nRegs+i*pCex->nPis+k) : (1 & Gia_ManRandom(0));
-        Gia_ManForEachAnd( p, pObj, k )
-            pObj->fMark0 = (Gia_ObjFanin0(pObj)->fMark0 ^ Gia_ObjFaninC0(pObj)) & 
-                           (Gia_ObjFanin1(pObj)->fMark0 ^ Gia_ObjFaninC1(pObj));
-        Gia_ManForEachCo( p, pObj, k )
-            pObj->fMark0 = Gia_ObjFanin0(pObj)->fMark0 ^ Gia_ObjFaninC0(pObj);
-        Gia_ManForEachRiRo( p, pObjRi, pObjRo, k )
-            pObjRo->fMark0 = pObjRi->fMark0;
-    }
-}
-Gia_Man_t * Gia_ManDupCycled( Gia_Man_t * p, Abc_Cex_t * pCex, int nFrames )
-{
-    Gia_Man_t * pNew;
-    Vec_Bit_t * vInits;
-    Gia_Obj_t * pObj;
-    int i;
-    Gia_ManCleanMark0(p);
-    Gia_ManCycle( p, pCex, nFrames );
-    vInits = Vec_BitAlloc( Gia_ManRegNum(p) );
-    Gia_ManForEachRo( p, pObj, i )
-        Vec_BitPush( vInits, pObj->fMark0 );
-    pNew = Gia_ManDupFlip( p, Vec_BitArray(vInits) );
-    Vec_BitFree( vInits );
-    Gia_ManCleanMark0(p);
-    return pNew;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates AIG without any changes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDup( Gia_Man_t * p )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i;
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    if ( Gia_ManHasChoices(p) )
-        pNew->pSibls = ABC_CALLOC( int, Gia_ManObjNum(p) );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachObj1( p, pObj, i )
-    {
-        if ( Gia_ObjIsBuf(pObj) )
-            pObj->Value = Gia_ManAppendBuf( pNew, Gia_ObjFanin0Copy(pObj) );
-        else if ( Gia_ObjIsAnd(pObj) )
-        {
-            pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-            if ( Gia_ObjSibl(p, Gia_ObjId(p, pObj)) )
-                pNew->pSibls[Abc_Lit2Var(pObj->Value)] = Abc_Lit2Var(Gia_ObjSiblObj(p, Gia_ObjId(p, pObj))->Value);  
-        }
-        else if ( Gia_ObjIsCi(pObj) )
-            pObj->Value = Gia_ManAppendCi( pNew );
-        else if ( Gia_ObjIsCo(pObj) )
-            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    }
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    if ( p->pCexSeq )
-        pNew->pCexSeq = Abc_CexDup( p->pCexSeq, Gia_ManRegNum(p) );
-    return pNew;
-}
-Gia_Man_t * Gia_ManDup2( Gia_Man_t * p1, Gia_Man_t * p2 )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i;
-    assert( Gia_ManCiNum(p1) == Gia_ManCiNum(p2) );
-    assert( Gia_ManCoNum(p1) == Gia_ManCoNum(p2) );
-    pNew = Gia_ManStart( Gia_ManObjNum(p1) + Gia_ManObjNum(p2) );
-    Gia_ManHashStart( pNew );
-    Gia_ManConst0(p1)->Value = 0;
-    Gia_ManConst0(p2)->Value = 0;
-    Gia_ManForEachCi( p1, pObj, i )
-        pObj->Value = Gia_ManCi(p2, i)->Value = Gia_ManAppendCi( pNew );
-    Gia_ManForEachAnd( p1, pObj, i )
-        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    Gia_ManForEachAnd( p2, pObj, i )
-        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    Gia_ManForEachCo( p1, pObj, i )
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManForEachCo( p2, pObj, i )
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p1) );
-    Gia_ManHashStop( pNew );
-    return pNew;
-}
-Gia_Man_t * Gia_ManDupWithAttributes( Gia_Man_t * p )
-{
-    Gia_Man_t * pNew = Gia_ManDup(p);
-    Gia_ManTransferMapping( pNew, p );
-    Gia_ManTransferPacking( pNew, p );
-    if ( p->pManTime )
-        pNew->pManTime = Tim_ManDup( (Tim_Man_t *)p->pManTime, 0 );
-    if ( p->pAigExtra )
-        pNew->pAigExtra = Gia_ManDup( p->pAigExtra );
-    if ( p->nAnd2Delay )
-        pNew->nAnd2Delay = p->nAnd2Delay;
-    if ( p->vRegClasses )
-        pNew->vRegClasses = Vec_IntDup( p->vRegClasses );
-    if ( p->vRegInits )
-        pNew->vRegInits = Vec_IntDup( p->vRegInits );
-    if ( p->vConfigs )
-        pNew->vConfigs = Vec_IntDup( p->vConfigs );
-    if ( p->pCellStr )
-        pNew->pCellStr = Abc_UtilStrsav( p->pCellStr );
-    return pNew;
-}
-Gia_Man_t * Gia_ManDupRemovePis( Gia_Man_t * p, int nRemPis )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i;
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachObj1( p, pObj, i )
-    {
-        if ( Gia_ObjIsAnd(pObj) )
-            pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-        else if ( Gia_ObjIsCi(pObj) && Gia_ObjCioId(pObj) < Gia_ManCiNum(p)-nRemPis )
-            pObj->Value = Gia_ManAppendCi( pNew );
-        else if ( Gia_ObjIsCo(pObj) )
-            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    }
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates AIG without any changes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupZero( Gia_Man_t * p )
-{
-    Gia_Man_t * pNew; int i;
-    pNew = Gia_ManStart( 1 + Gia_ManCiNum(p) + Gia_ManCoNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    for ( i = 0; i < Gia_ManCiNum(p); i++ )
-        Gia_ManAppendCi( pNew );
-    for ( i = 0; i < Gia_ManCoNum(p); i++ )
-        Gia_ManAppendCo( pNew, 0 );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates AIG without any changes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupPerm( Gia_Man_t * p, Vec_Int_t * vPiPerm )
-{
-//    Vec_Int_t * vPiPermInv;
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i;
-    assert( Vec_IntSize(vPiPerm) == Gia_ManPiNum(p) );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-//    vPiPermInv = Vec_IntInvert( vPiPerm, -1 );
-    Gia_ManForEachPi( p, pObj, i )
-//        Gia_ManPi(p, Vec_IntEntry(vPiPermInv,i))->Value = Gia_ManAppendCi( pNew );
-        Gia_ManPi(p, Vec_IntEntry(vPiPerm,i))->Value = Gia_ManAppendCi( pNew );
-//    Vec_IntFree( vPiPermInv );
-    Gia_ManForEachObj1( p, pObj, i )
-    {
-        if ( Gia_ObjIsAnd(pObj) )
-            pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-        else if ( Gia_ObjIsCi(pObj) )
-        {
-            if ( Gia_ObjIsRo(p, pObj) )
-                pObj->Value = Gia_ManAppendCi( pNew );
-        }
-        else if ( Gia_ObjIsCo(pObj) )
-            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    }
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    return pNew;
-}
-Gia_Man_t * Gia_ManDupPermFlop( Gia_Man_t * p, Vec_Int_t * vFfPerm )
-{
-    Vec_Int_t * vPermInv;
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i;
-    assert( Vec_IntSize(vFfPerm) == Gia_ManRegNum(p) );
-    vPermInv = Vec_IntInvert( vFfPerm, -1 );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachPi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi(pNew);
-    Gia_ManForEachRo( p, pObj, i )
-        Gia_ManRo(p, Vec_IntEntry(vPermInv, i))->Value = Gia_ManAppendCi(pNew);
-    Gia_ManForEachAnd( p, pObj, i )
-        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    Gia_ManForEachPo( p, pObj, i )
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManForEachRi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy( Gia_ManRi(p, Vec_IntEntry(vPermInv, i)) ) );
-    Vec_IntFree( vPermInv );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    return pNew;
-}
-Gia_Man_t * Gia_ManDupSpreadFlop( Gia_Man_t * p, Vec_Int_t * vFfMask )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i, k, Entry;
-    assert( Vec_IntSize(vFfMask) >= Gia_ManRegNum(p) );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachPi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi(pNew);
-    k = 0;
-    Vec_IntForEachEntry( vFfMask, Entry, i )
-        if ( Entry == -1 )
-            Gia_ManAppendCi(pNew);
-        else
-            Gia_ManRo(p, k++)->Value = Gia_ManAppendCi(pNew);
-    assert( k == Gia_ManRegNum(p) );
-    Gia_ManForEachAnd( p, pObj, i )
-        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    Gia_ManForEachPo( p, pObj, i )
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    k = 0;
-    Vec_IntForEachEntry( vFfMask, Entry, i )
-        if ( Entry == -1 )
-            Gia_ManAppendCo( pNew, 0 );
-        else
-        {
-            pObj = Gia_ManRi( p, k++ );
-            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-        }
-    assert( k == Gia_ManRegNum(p) );
-    Gia_ManSetRegNum( pNew, Vec_IntSize(vFfMask) );
-    return pNew;
-}
-Gia_Man_t * Gia_ManDupPermFlopGap( Gia_Man_t * p, Vec_Int_t * vFfMask )
-{
-    Vec_Int_t * vPerm = Vec_IntCondense( vFfMask, -1 );
-    Gia_Man_t * pPerm = Gia_ManDupPermFlop( p, vPerm );
-    Gia_Man_t * pSpread = Gia_ManDupSpreadFlop( pPerm, vFfMask );
-    Vec_IntFree( vPerm );
-    Gia_ManStop( pPerm );
-    return pSpread;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Appends second AIG without any changes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Gia_ManDupAppend( Gia_Man_t * pNew, Gia_Man_t * pTwo )
-{
-    Gia_Obj_t * pObj;
-    int i;
-    if ( pNew->nRegs > 0 )
-        pNew->nRegs = 0;
-    if ( Vec_IntSize(&pNew->vHTable) == 0 )
-        Gia_ManHashStart( pNew );
-    Gia_ManConst0(pTwo)->Value = 0;
-    Gia_ManForEachObj1( pTwo, pObj, i )
-    {
-        if ( Gia_ObjIsAnd(pObj) )
-            pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-        else if ( Gia_ObjIsCi(pObj) )
-            pObj->Value = Gia_ManAppendCi( pNew );
-        else if ( Gia_ObjIsCo(pObj) )
-            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    }
-}
-void Gia_ManDupAppendShare( Gia_Man_t * pNew, Gia_Man_t * pTwo )
-{
-    Gia_Obj_t * pObj;
-    int i;
-    assert( Gia_ManCiNum(pNew) == Gia_ManCiNum(pTwo) );
-    if ( Vec_IntSize(&pNew->vHTable) == 0 )
-        Gia_ManHashStart( pNew );
-    Gia_ManConst0(pTwo)->Value = 0;
-    Gia_ManForEachObj1( pTwo, pObj, i )
-    {
-        if ( Gia_ObjIsAnd(pObj) )
-            pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-        else if ( Gia_ObjIsCi(pObj) )
-            pObj->Value = Gia_Obj2Lit( pNew, Gia_ManCi( pNew, Gia_ObjCioId(pObj) ) );
-        else if ( Gia_ObjIsCo(pObj) )
-            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    }
-}
-Gia_Man_t * Gia_ManDupAppendNew( Gia_Man_t * pOne, Gia_Man_t * pTwo )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i;
-    pNew = Gia_ManStart( Gia_ManObjNum(pOne) + Gia_ManObjNum(pTwo) );
-    pNew->pName = Abc_UtilStrsav( pOne->pName );
-    pNew->pSpec = Abc_UtilStrsav( pOne->pSpec );
-    Gia_ManHashAlloc( pNew );
-    Gia_ManConst0(pOne)->Value = 0;
-    Gia_ManForEachObj1( pOne, pObj, i )
-    {
-        if ( Gia_ObjIsAnd(pObj) )
-            pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-        else if ( Gia_ObjIsCi(pObj) )
-            pObj->Value = Gia_ManAppendCi( pNew );
-    }
-    Gia_ManConst0(pTwo)->Value = 0;
-    Gia_ManForEachObj1( pTwo, pObj, i )
-    {
-        if ( Gia_ObjIsAnd(pObj) )
-            pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-        else if ( Gia_ObjIsPi(pTwo, pObj) )
-            pObj->Value = Gia_ManPi(pOne, Gia_ObjCioId(pObj))->Value;
-        else if ( Gia_ObjIsCi(pObj) )
-            pObj->Value = Gia_ManAppendCi( pNew );
-    }
-    Gia_ManHashStop( pNew );
-    // primary outputs
-    Gia_ManForEachPo( pOne, pObj, i )
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManForEachPo( pTwo, pObj, i )
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    // flop inputs
-    Gia_ManForEachRi( pOne, pObj, i )
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManForEachRi( pTwo, pObj, i )
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(pOne) + Gia_ManRegNum(pTwo) );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Creates a miter for inductive checking of the invariant.]
-
-  Description [The first GIA (p) is a sequential AIG whose transition
-  relation is used. The second GIA (pInv) is a combinational AIG representing
-  the invariant over the register outputs. If the resulting combination miter
-  is UNSAT, the invariant holds by simple induction.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupInvMiter( Gia_Man_t * p, Gia_Man_t * pInv )
-{
-    Gia_Man_t * pNew, * pTemp;
-    Gia_Obj_t * pObj;
-    int i, Node1, Node2, Node;
-    assert( Gia_ManRegNum(p) > 0 );
-    assert( Gia_ManRegNum(pInv) == 0 );
-    assert( Gia_ManCoNum(pInv) == 1 );
-    assert( Gia_ManRegNum(p) == Gia_ManCiNum(pInv) );
-    Gia_ManFillValue(p);
-    pNew = Gia_ManStart( Gia_ManObjNum(p) + 2*Gia_ManObjNum(pInv) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManHashAlloc( pNew );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachObj1( p, pObj, i )
-    {
-        if ( Gia_ObjIsAnd(pObj) )
-            pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-        else if ( Gia_ObjIsCi(pObj) )
-            pObj->Value = Gia_ManAppendCi( pNew );
-        else if ( Gia_ObjIsCo(pObj) )
-            pObj->Value = Gia_ObjFanin0Copy(pObj);
-    }
-    // build invariant on top of register outputs in the first frame
-    Gia_ManForEachRo( p, pObj, i )
-        Gia_ManCi(pInv, i)->Value = pObj->Value;
-    Gia_ManForEachAnd( pInv, pObj, i )
-        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    pObj = Gia_ManCo( pInv, 0 );
-    Node1 = Gia_ObjFanin0Copy(pObj);
-    // build invariant on top of register outputs in the second frame
-    Gia_ManForEachRi( p, pObj, i )
-        Gia_ManCi(pInv, i)->Value = pObj->Value;
-    Gia_ManForEachAnd( pInv, pObj, i )
-        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    pObj = Gia_ManCo( pInv, 0 );
-    Node2 = Gia_ObjFanin0Copy(pObj);
-    // create miter output
-    Node = Gia_ManHashAnd( pNew, Node1, Abc_LitNot(Node2) );
-    Gia_ManAppendCo( pNew, Node );
-    // cleanup
-    pNew = Gia_ManCleanup( pTemp = pNew );
-    Gia_ManStop( pTemp );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Appends logic cones as additional property outputs.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupAppendCones( Gia_Man_t * p, Gia_Man_t ** ppCones, int nCones, int fOnlyRegs )
-{
-    Gia_Man_t * pNew, * pOne;
-    Gia_Obj_t * pObj;
-    int i, k;
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManHashAlloc( pNew );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachCi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi( pNew );
-    Gia_ManForEachAnd( p, pObj, i )
-        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    Gia_ManForEachPo( p, pObj, i )
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    for ( k = 0; k < nCones; k++ )
-    {
-        pOne = ppCones[k];
-        assert( Gia_ManPoNum(pOne) == 1 );
-        assert( Gia_ManRegNum(pOne) == 0 );
-        if ( fOnlyRegs )
-            assert( Gia_ManPiNum(pOne) == Gia_ManRegNum(p) );
-        else
-            assert( Gia_ManPiNum(pOne) == Gia_ManCiNum(p) );
-        Gia_ManConst0(pOne)->Value = 0;
-        Gia_ManForEachPi( pOne, pObj, i )
-            pObj->Value = Gia_ManCiLit( pNew, fOnlyRegs ? Gia_ManPiNum(p) + i : i );
-        Gia_ManForEachAnd( pOne, pObj, i )
-            pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-        Gia_ManForEachPo( pOne, pObj, i )
-            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    }
-    Gia_ManForEachRi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManHashStop( pNew );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    pNew = Gia_ManCleanup( pOne = pNew );
-    Gia_ManStop( pOne );
-    return pNew;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates while adding self-loops to the registers.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupSelf( Gia_Man_t * p )
-{
-    Gia_Man_t * pNew, * pTemp; 
-    Gia_Obj_t * pObj;
-    int i, iCtrl;
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManHashAlloc( pNew );
-    Gia_ManFillValue( p );
-    Gia_ManConst0(p)->Value = 0;
-    iCtrl = Gia_ManAppendCi( pNew );
-    Gia_ManForEachCi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi( pNew );
-    Gia_ManForEachAnd( p, pObj, i )
-        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    Gia_ManForEachPo( p, pObj, i )
-        pObj->Value = Gia_ObjFanin0Copy(pObj);
-    Gia_ManForEachRi( p, pObj, i )
-        pObj->Value = Gia_ManHashMux( pNew, iCtrl, Gia_ObjFanin0Copy(pObj), Gia_ObjRiToRo(p, pObj)->Value );
-    Gia_ManForEachCo( p, pObj, i )
-        Gia_ManAppendCo( pNew, pObj->Value );
-    Gia_ManHashStop( pNew );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    pNew = Gia_ManCleanup( pTemp = pNew );
-    Gia_ManStop( pTemp );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates while adding self-loops to the registers.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupFlopClass( Gia_Man_t * p, int iClass )
-{
-    Gia_Man_t * pNew; 
-    Gia_Obj_t * pObj;
-    int i, Counter1 = 0, Counter2 = 0;
-    assert( p->vFlopClasses != NULL );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManFillValue( p );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachPi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi( pNew );
-    Gia_ManForEachRo( p, pObj, i )
-        if ( Vec_IntEntry(p->vFlopClasses, i) != iClass )
-            pObj->Value = Gia_ManAppendCi( pNew );
-    Gia_ManForEachRo( p, pObj, i )
-        if ( Vec_IntEntry(p->vFlopClasses, i) == iClass )
-            pObj->Value = Gia_ManAppendCi( pNew ), Counter1++;
-    Gia_ManForEachAnd( p, pObj, i )
-        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    Gia_ManForEachPo( p, pObj, i )
-        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManForEachRi( p, pObj, i )
-        if ( Vec_IntEntry(p->vFlopClasses, i) != iClass )
-            Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManForEachRi( p, pObj, i )
-        if ( Vec_IntEntry(p->vFlopClasses, i) == iClass )
-            Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) ), Counter2++;
-    assert( Counter1 == Counter2 );
-    Gia_ManSetRegNum( pNew, Counter1 );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates AIG without any changes.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupMarked( Gia_Man_t * p )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i, nRos = 0, nRis = 0;
-    int CountMarked = 0;
-    Gia_ManForEachObj( p, pObj, i )
-        CountMarked += pObj->fMark0;
-    Gia_ManFillValue( p );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) - CountMarked );
-    if ( p->pMuxes )
-        pNew->pMuxes = ABC_CALLOC( unsigned, pNew->nObjsAlloc );
-    pNew->nConstrs = p->nConstrs;
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachObj1( p, pObj, i )
-    {
-        if ( pObj->fMark0 )
-        {
-            assert( !Gia_ObjIsBuf(pObj) );
-            pObj->fMark0 = 0;
-            continue;
-        }
-        if ( Gia_ObjIsBuf(pObj) )
-            pObj->Value = Gia_ManAppendBuf( pNew, Gia_ObjFanin0Copy(pObj) );
-        else if ( Gia_ObjIsAnd(pObj) )
-        {
-            if ( Gia_ObjIsXor(pObj) )
-                pObj->Value = Gia_ManAppendXorReal( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-            else if ( Gia_ObjIsMux(p, pObj) )
-                pObj->Value = Gia_ManAppendMuxReal( pNew, Gia_ObjFanin2Copy(p, pObj), Gia_ObjFanin1Copy(pObj), Gia_ObjFanin0Copy(pObj) );
-            else
-                pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-        }
-        else if ( Gia_ObjIsCi(pObj) )
-        {
-            pObj->Value = Gia_ManAppendCi( pNew );
-            nRos += Gia_ObjIsRo(p, pObj);
-        }
-        else if ( Gia_ObjIsCo(pObj) )
-        {
-//            Gia_Obj_t * pFanin = Gia_ObjFanin0(pObj);
-            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-            nRis += Gia_ObjIsRi(p, pObj);
-        }
-    }
-    assert( pNew->nObjsAlloc == pNew->nObjs );
-    assert( nRos == nRis );
-    Gia_ManSetRegNum( pNew, nRos );
-    if ( p->pReprs && p->pNexts )
-    {
-        Gia_Obj_t * pRepr;
-        pNew->pReprs = ABC_CALLOC( Gia_Rpr_t, Gia_ManObjNum(pNew) );
-        for ( i = 0; i < Gia_ManObjNum(p); i++ )
-            Gia_ObjSetRepr( pNew, i, GIA_VOID );
-        Gia_ManForEachObj1( p, pObj, i )
-        {
-            if ( !~pObj->Value )
-                continue;
-            pRepr = Gia_ObjReprObj( p, i );
-            if ( pRepr == NULL )
-                continue;
-            if ( !~pRepr->Value )
-                continue;
-            assert( !Gia_ObjIsBuf(pObj) );
-            if ( Abc_Lit2Var(pObj->Value) != Abc_Lit2Var(pRepr->Value) )
-                Gia_ObjSetRepr( pNew, Abc_Lit2Var(pObj->Value), Abc_Lit2Var(pRepr->Value) ); 
-        }
-        pNew->pNexts = Gia_ManDeriveNexts( pNew );
-    }
-    if ( Gia_ManHasChoices(p) )
-    {
-        Gia_Obj_t * pSibl;
-        pNew->pSibls = ABC_CALLOC( int, Gia_ManObjNum(pNew) );
-        Gia_ManForEachObj1( p, pObj, i )
-        {
-            if ( !~pObj->Value )
-                continue;
-            pSibl = Gia_ObjSiblObj( p, i );
-            if ( pSibl == NULL )
-                continue;
-            if ( !~pSibl->Value )
-                continue;
-            assert( !Gia_ObjIsBuf(pObj) );
-            assert( Abc_Lit2Var(pObj->Value) > Abc_Lit2Var(pSibl->Value) );
-            pNew->pSibls[Abc_Lit2Var(pObj->Value)] = Abc_Lit2Var(pSibl->Value);
-        }
-    }
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates AIG while creating "parallel" copies.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupTimes( Gia_Man_t * p, int nTimes )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    Vec_Int_t * vPis, * vPos, * vRis, * vRos;
-    int i, t, Entry;
-    assert( nTimes > 0 );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    vPis = Vec_IntAlloc( Gia_ManPiNum(p) * nTimes );
-    vPos = Vec_IntAlloc( Gia_ManPoNum(p) * nTimes );
-    vRis = Vec_IntAlloc( Gia_ManRegNum(p) * nTimes );
-    vRos = Vec_IntAlloc( Gia_ManRegNum(p) * nTimes );
-    for ( t = 0; t < nTimes; t++ )
-    {
-        Gia_ManForEachObj1( p, pObj, i )
-        {
-            if ( Gia_ObjIsAnd(pObj) )
-                pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-            else if ( Gia_ObjIsCi(pObj) )
-            {
-                pObj->Value = Gia_ManAppendCi( pNew );
-                if ( Gia_ObjIsPi(p, pObj) )
-                    Vec_IntPush( vPis, Abc_Lit2Var(pObj->Value) );
-                else
-                    Vec_IntPush( vRos, Abc_Lit2Var(pObj->Value) );
-            }
-            else if ( Gia_ObjIsCo(pObj) )
-            {
-                pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-                if ( Gia_ObjIsPo(p, pObj) )
-                    Vec_IntPush( vPos, Abc_Lit2Var(pObj->Value) );
-                else
-                    Vec_IntPush( vRis, Abc_Lit2Var(pObj->Value) );
-            }
-        }
-    }
-    Vec_IntClear( pNew->vCis );
-    Vec_IntForEachEntry( vPis, Entry, i )
-    {
-        Gia_ObjSetCioId( Gia_ManObj(pNew, Entry), Vec_IntSize(pNew->vCis) );
-        Vec_IntPush( pNew->vCis, Entry );
-    }
-    Vec_IntForEachEntry( vRos, Entry, i )
-    {
-        Gia_ObjSetCioId( Gia_ManObj(pNew, Entry), Vec_IntSize(pNew->vCis) );
-        Vec_IntPush( pNew->vCis, Entry );
-    }
-    Vec_IntClear( pNew->vCos );
-    Vec_IntForEachEntry( vPos, Entry, i )
-    {
-        Gia_ObjSetCioId( Gia_ManObj(pNew, Entry), Vec_IntSize(pNew->vCos) );
-        Vec_IntPush( pNew->vCos, Entry );
-    }
-    Vec_IntForEachEntry( vRis, Entry, i )
-    {
-        Gia_ObjSetCioId( Gia_ManObj(pNew, Entry), Vec_IntSize(pNew->vCos) );
-        Vec_IntPush( pNew->vCos, Entry );
-    }
-    Vec_IntFree( vPis );
-    Vec_IntFree( vPos );
-    Vec_IntFree( vRis );
-    Vec_IntFree( vRos );
-    Gia_ManSetRegNum( pNew, nTimes * Gia_ManRegNum(p) );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates the AIG in the DFS order.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Gia_ManDupDfs2_rec( Gia_Man_t * pNew, Gia_Man_t * p, Gia_Obj_t * pObj )
-{
-    if ( ~pObj->Value )
-        return pObj->Value;
-    if ( p->pReprsOld && ~p->pReprsOld[Gia_ObjId(p, pObj)] )
-    {
-        Gia_Obj_t * pRepr = Gia_ManObj( p, p->pReprsOld[Gia_ObjId(p, pObj)] );
-        pRepr->Value = Gia_ManDupDfs2_rec( pNew, p, pRepr );
-        return pObj->Value = Abc_LitNotCond( pRepr->Value, Gia_ObjPhaseReal(pRepr) ^ Gia_ObjPhaseReal(pObj) );
-    }
-    if ( Gia_ObjIsCi(pObj) )
-        return pObj->Value = Gia_ManAppendCi(pNew);
-    Gia_ManDupDfs2_rec( pNew, p, Gia_ObjFanin0(pObj) );
-    if ( Gia_ObjIsCo(pObj) )
-        return pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManDupDfs2_rec( pNew, p, Gia_ObjFanin1(pObj) );
-    if ( Vec_IntSize(&pNew->vHTable) )
-        return pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    return pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-} 
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates AIG in the DFS order.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupDfs2( Gia_Man_t * p )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj, * pObjNew;
-    int i;
-    Gia_ManFillValue( p );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachCo( p, pObj, i )
-        Gia_ManDupDfs2_rec( pNew, p, pObj );
-    Gia_ManForEachCi( p, pObj, i )
-        if ( ~pObj->Value == 0 )
-            pObj->Value = Gia_ManAppendCi(pNew);
-    assert( Gia_ManCiNum(pNew) == Gia_ManCiNum(p) );
-    // remap combinational inputs
-    Gia_ManForEachCi( p, pObj, i )
-    {
-        pObjNew = Gia_ObjFromLit( pNew, pObj->Value );
-        assert( !Gia_IsComplement(pObjNew) );
-        Vec_IntWriteEntry( pNew->vCis, Gia_ObjCioId(pObj), Gia_ObjId(pNew, pObjNew) );
-        Gia_ObjSetCioId( pObjNew, Gia_ObjCioId(pObj) );
-    }
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates the AIG in the DFS order.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Gia_ManDupDfs_rec( Gia_Man_t * pNew, Gia_Man_t * p, Gia_Obj_t * pObj )
-{
-    if ( ~pObj->Value )
-        return;
-    assert( Gia_ObjIsAnd(pObj) );
-    Gia_ManDupDfs_rec( pNew, p, Gia_ObjFanin0(pObj) );
-    Gia_ManDupDfs_rec( pNew, p, Gia_ObjFanin1(pObj) );
-    pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-}
-Gia_Man_t * Gia_ManDupDfs( Gia_Man_t * p )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i;
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManFillValue( p );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachCi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi(pNew);
-    Gia_ManForEachCo( p, pObj, i )
-        Gia_ManDupDfs_rec( pNew, p, Gia_ObjFanin0(pObj) );
-    Gia_ManForEachCo( p, pObj, i )
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    pNew->nConstrs = p->nConstrs;
-    if ( p->pCexSeq )
-        pNew->pCexSeq = Abc_CexDup( p->pCexSeq, Gia_ManRegNum(p) );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Cofactors w.r.t. a primary input variable.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Gia_ManDupCofactorVar_rec( Gia_Man_t * pNew, Gia_Man_t * p, Gia_Obj_t * pObj )
-{
-    if ( ~pObj->Value )
-        return;
-    assert( Gia_ObjIsAnd(pObj) );
-    Gia_ManDupCofactorVar_rec( pNew, p, Gia_ObjFanin0(pObj) );
-    Gia_ManDupCofactorVar_rec( pNew, p, Gia_ObjFanin1(pObj) );
-    pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-}
-Gia_Man_t * Gia_ManDupCofactorVar( Gia_Man_t * p, int iVar, int Value )
-{
-    Gia_Man_t * pNew, * pTemp;
-    Gia_Obj_t * pObj;
-    int i;
-    assert( iVar >= 0 && iVar < Gia_ManPiNum(p) );
-    assert( Value == 0 || Value == 1 );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManFillValue( p );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachCi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi(pNew);
-    Gia_ManPi( p, iVar )->Value = Value; // modification!
-    Gia_ManHashAlloc( pNew );
-    Gia_ManForEachCo( p, pObj, i )
-        Gia_ManDupCofactorVar_rec( pNew, p, Gia_ObjFanin0(pObj) );
-    Gia_ManForEachCo( p, pObj, i )
-        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    pNew->nConstrs = p->nConstrs;
-    pNew = Gia_ManCleanup( pTemp = pNew );
-    Gia_ManStop( pTemp );
-    return pNew;
-}
-Gia_Man_t * Gia_ManDupMux( int iVar, Gia_Man_t * pCof1, Gia_Man_t * pCof0 )
-{
-    Gia_Man_t * pGia[2] = {pCof0, pCof1};
-    Gia_Man_t * pNew, * pTemp;
-    Gia_Obj_t * pObj;
-    int i, n;
-    assert( Gia_ManRegNum(pCof0) == 0 );
-    assert( Gia_ManRegNum(pCof1) == 0 );
-    assert( Gia_ManCoNum(pCof0) == 1 );
-    assert( Gia_ManCoNum(pCof1) == 1 );
-    assert( Gia_ManCiNum(pCof1) == Gia_ManCiNum(pCof0) );
-    assert( iVar >= 0 && iVar < Gia_ManCiNum(pCof1) );
-    pNew = Gia_ManStart( Gia_ManObjNum(pCof1) + Gia_ManObjNum(pCof0) );
-    pNew->pName = Abc_UtilStrsav( pCof1->pName );
-    pNew->pSpec = Abc_UtilStrsav( pCof1->pSpec );
-    Gia_ManHashAlloc( pNew );
-    for ( n = 0; n < 2; n++ )
-    {
-        Gia_ManFillValue( pGia[n] );
-        Gia_ManConst0(pGia[n])->Value = 0;
-        Gia_ManForEachCi( pGia[n], pObj, i )
-            pObj->Value = n ? Gia_ManCi(pGia[0], i)->Value : Gia_ManAppendCi(pNew);
-        Gia_ManForEachCo( pGia[n], pObj, i )
-            Gia_ManDupCofactorVar_rec( pNew, pGia[n], Gia_ObjFanin0(pObj) );
-    }
-    Gia_ManForEachCo( pGia[0], pObj, i )
-    {
-        int Ctrl = Gia_ManCi(pGia[0], iVar)->Value;
-        int Lit1 = Gia_ObjFanin0Copy(Gia_ManCo(pGia[1], i));
-        int Lit0 = Gia_ObjFanin0Copy(pObj);
-        Gia_ManAppendCo( pNew, Gia_ManHashMux( pNew, Ctrl, Lit1, Lit0 ) );
-    }
-    pNew = Gia_ManCleanup( pTemp = pNew );
-    Gia_ManStop( pTemp );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Cofactors w.r.t. an internal node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupCofactorObj( Gia_Man_t * p, int iObj, int Value )
-{
-    Gia_Man_t * pNew, * pTemp;
-    Gia_Obj_t * pObj;
-    int i, iObjValue = -1;
-    assert( Gia_ManRegNum(p) == 0 );
-    assert( iObj > 0 && iObj < Gia_ManObjNum(p) );
-    assert( Gia_ObjIsCand(Gia_ManObj(p, iObj)) );
-    assert( Value == 0 || Value == 1 );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManHashAlloc( pNew );
-    Gia_ManForEachObj1( p, pObj, i )
-    {
-        if ( Gia_ObjIsCi(pObj) )
-            pObj->Value = Gia_ManAppendCi( pNew );
-        else if ( Gia_ObjIsAnd(pObj) )
-            pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-        else if ( Gia_ObjIsCo(pObj) )
-            pObj->Value = Gia_ManAppendCo( pNew, Gia_ManHashAnd(pNew, Gia_ObjFanin0Copy(pObj), iObjValue) );
-        if ( i == iObj )
-            iObjValue = Abc_LitNotCond(pObj->Value, !Value), pObj->Value = Value;
-    }
-    pNew = Gia_ManCleanup( pTemp = pNew );
-    Gia_ManStop( pTemp );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Reduce bit-width of GIA assuming it is Boolean.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupBlock( Gia_Man_t * p, int nBlock )
-{
-    Gia_Man_t * pNew, * pTemp;
-    Gia_Obj_t * pObj; int i;
-    assert( Gia_ManCiNum(p) % nBlock == 0 );
-    assert( Gia_ManCoNum(p) % nBlock == 0 );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManFillValue( p );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachCi( p, pObj, i )
-        pObj->Value = (i % nBlock == 0) ? Gia_ManAppendCi(pNew) : 0;
-    Gia_ManHashAlloc( pNew );
-    Gia_ManForEachAnd( p, pObj, i )
-        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    Gia_ManForEachCo( p, pObj, i )
-        if ( i % nBlock == 0 )
-            Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p)/nBlock );
-    pNew = Gia_ManCleanup( pTemp = pNew );
-    Gia_ManStop( pTemp );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Existentially quantified given variable.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupExist( Gia_Man_t * p, int iVar )
-{
-    Gia_Man_t * pNew, * pTemp;
-    Gia_Obj_t * pObj;
-    int i;
-    assert( iVar >= 0 && iVar < Gia_ManPiNum(p) );
-    assert( Gia_ManPoNum(p) == 1 );
-    assert( Gia_ManRegNum(p) == 0 );
-    Gia_ManFillValue( p );
-    // find the cofactoring variable
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManHashAlloc( pNew );
-    // compute negative cofactor
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachCi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi(pNew);
-    Gia_ManPi( p, iVar )->Value = Abc_Var2Lit( 0, 0 );
-    Gia_ManForEachAnd( p, pObj, i )
-        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    Gia_ManForEachPo( p, pObj, i )
-        pObj->Value = Gia_ObjFanin0Copy(pObj);
-    // compute the positive cofactor
-    Gia_ManPi( p, iVar )->Value = Abc_Var2Lit( 0, 1 );
-    Gia_ManForEachAnd( p, pObj, i )
-        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    // create OR gate
-    Gia_ManForEachPo( p, pObj, i )
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ManHashOr(pNew, Gia_ObjFanin0Copy(pObj), pObj->Value) );
-    Gia_ManHashStop( pNew );
-    pNew = Gia_ManCleanup( pTemp = pNew );
-    Gia_ManStop( pTemp );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Existentially quantified given variable.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupUniv( Gia_Man_t * p, int iVar )
-{
-    Gia_Man_t * pNew, * pTemp;
-    Gia_Obj_t * pObj;
-    int i;
-    assert( iVar >= 0 && iVar < Gia_ManPiNum(p) );
-    assert( Gia_ManRegNum(p) == 0 );
-    Gia_ManFillValue( p );
-    // find the cofactoring variable
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManHashAlloc( pNew );
-    // compute negative cofactor
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachCi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi(pNew);
-    Gia_ManPi( p, iVar )->Value = Abc_Var2Lit( 0, 0 );
-    Gia_ManForEachAnd( p, pObj, i )
-        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    Gia_ManForEachPo( p, pObj, i )
-        pObj->Value = Gia_ObjFanin0Copy(pObj);
-    // compute the positive cofactor
-    Gia_ManPi( p, iVar )->Value = Abc_Var2Lit( 0, 1 );
-    Gia_ManForEachAnd( p, pObj, i )
-        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    // create OR gate
-    Gia_ManForEachPo( p, pObj, i )
-    {
-        if ( i == 0 )
-            pObj->Value = Gia_ManAppendCo( pNew, Gia_ManHashAnd(pNew, Gia_ObjFanin0Copy(pObj), pObj->Value) );
-        else 
-            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    }
-    Gia_ManHashStop( pNew );
-    pNew = Gia_ManCleanup( pTemp = pNew );
-    Gia_ManStop( pTemp );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Existentially quantifies the given variable.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupExist2( Gia_Man_t * p, int iVar )
-{
-    Gia_Man_t * pNew, * pTemp;
-    Gia_Obj_t * pObj;
-    int i;
-    assert( iVar >= 0 && iVar < Gia_ManPiNum(p) );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManFillValue( p );
-    Gia_ManHashAlloc( pNew );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachCi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi(pNew);
-    // first part
-    Gia_ManPi( p, iVar )->Value = 0; // modification!
-    Gia_ManForEachCo( p, pObj, i )
-        Gia_ManDupCofactorVar_rec( pNew, p, Gia_ObjFanin0(pObj) );
-    Gia_ManForEachCo( p, pObj, i )
-        pObj->Value = Gia_ObjFanin0Copy(pObj);
-    // second part
-    Gia_ManPi( p, iVar )->Value = 1; // modification!
-    Gia_ManForEachAnd( p, pObj, i )
-        pObj->Value = ~0;
-    Gia_ManForEachCo( p, pObj, i )
-        Gia_ManDupCofactorVar_rec( pNew, p, Gia_ObjFanin0(pObj) );
-    // combination
-    Gia_ManForEachCo( p, pObj, i )
-        Gia_ManAppendCo( pNew, Gia_ManHashOr(pNew, Gia_ObjFanin0Copy(pObj), pObj->Value) );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    pNew->nConstrs = p->nConstrs;
-    pNew = Gia_ManCleanup( pTemp = pNew );
-    Gia_ManStop( pTemp );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Existentially quantified several variables.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-
-static inline word * Gia_ManQuantInfoId( Gia_Man_t * p, int iObj )       { return Vec_WrdEntryP( p->vSuppWords, p->nSuppWords * iObj ); }
-static inline word * Gia_ManQuantInfo( Gia_Man_t * p, Gia_Obj_t * pObj ) { return Gia_ManQuantInfoId( p, Gia_ObjId(p, pObj) );      }
-
-static inline void   Gia_ObjCopyGetTwoArray( Gia_Man_t * p, int iObj, int LitsOut[2] )      
-{ 
-    int * pLits = Vec_IntEntryP( &p->vCopiesTwo, 2*iObj );
-    LitsOut[0] = pLits[0];
-    LitsOut[1] = pLits[1];
-}
-static inline void   Gia_ObjCopySetTwoArray( Gia_Man_t * p, int iObj, int LitsIn[2] )      
-{ 
-    int * pLits = Vec_IntEntryP( &p->vCopiesTwo, 2*iObj );
-    pLits[0] = LitsIn[0];
-    pLits[1] = LitsIn[1];
-}
-
-void Gia_ManQuantSetSuppStart( Gia_Man_t * p )
-{
-    assert( Gia_ManObjNum(p) == 1 );
-    assert( p->vSuppWords == NULL );
-    p->iSuppPi    = 0;
-    p->nSuppWords = 1;
-    p->vSuppWords = Vec_WrdAlloc( 1000 );
-    Vec_WrdPush( p->vSuppWords, 0 );
-}
-void Gia_ManQuantSetSuppZero( Gia_Man_t * p )
-{
-    int w;
-    for ( w = 0; w < p->nSuppWords; w++ )
-        Vec_WrdPush( p->vSuppWords, 0 );
-    assert( Vec_WrdSize(p->vSuppWords) == p->nSuppWords * Gia_ManObjNum(p) );
-}
-void Gia_ManQuantSetSuppCi( Gia_Man_t * p, Gia_Obj_t * pObj )
-{
-    assert( Gia_ObjIsCi(pObj) );
-    assert( p->vSuppWords != NULL );
-    if ( p->iSuppPi == 64 * p->nSuppWords )
-    {
-        Vec_Wrd_t * vTemp = Vec_WrdAlloc( 1000 ); word Data; int w;
-        Vec_WrdForEachEntry( p->vSuppWords, Data, w )
-        {
-            Vec_WrdPush( vTemp, Data );
-            if ( w % p->nSuppWords == 0 )
-                Vec_WrdPush( vTemp, 0 );
-        }
-        Vec_WrdFree( p->vSuppWords );
-        p->vSuppWords = vTemp;
-        p->nSuppWords++;
-    }
-    Gia_ManQuantSetSuppZero( p );
-    Abc_TtSetBit( Gia_ManQuantInfo(p, pObj), p->iSuppPi++ );
-}
-void Gia_ManQuantSetSuppAnd( Gia_Man_t * p, Gia_Obj_t * pObj )
-{
-    int iObj  = Gia_ObjId(p, pObj);
-    int iFan0 = Gia_ObjFaninId0(pObj, iObj);
-    int iFan1 = Gia_ObjFaninId1(pObj, iObj);
-    assert( Gia_ObjIsAnd(pObj) );
-    Gia_ManQuantSetSuppZero( p );
-    Abc_TtOr( Gia_ManQuantInfo(p, pObj), Gia_ManQuantInfoId(p, iFan0), Gia_ManQuantInfoId(p, iFan1), p->nSuppWords );
-}
-int Gia_ManQuantCheckSupp( Gia_Man_t * p, int iObj, int iSupp )
-{
-    return Abc_TtGetBit( Gia_ManQuantInfoId(p, iObj), iSupp );
-}
-
-
-void Gia_ManQuantDupConeSupp_rec( Gia_Man_t * pNew, Gia_Man_t * p, Gia_Obj_t * pObj, Vec_Int_t * vCis, Vec_Int_t * vObjs, int(*pFuncCiToKeep)(void *, int), void * pData )
-{
-    int iLit0, iLit1, iObj = Gia_ObjId( p, pObj );
-    int iLit = Gia_ObjCopyArray( p, iObj );
-    if ( iLit >= 0 )
-        return;
-    if ( Gia_ObjIsCi(pObj) )
-    {
-        int iLit = Gia_ManAppendCi( pNew );
-        Gia_Obj_t * pObjNew = Gia_ManObj( pNew, Abc_Lit2Var(iLit) );
-        if ( pFuncCiToKeep( pData, Gia_ObjCioId(pObj) ) )
-            Gia_ManQuantSetSuppZero( pNew );
-        else
-            Gia_ManQuantSetSuppCi( pNew, pObjNew );
-        Gia_ObjSetCopyArray( p, iObj, iLit );
-        Vec_IntPush( vCis, iObj );
-        return;
-    }
-    assert( Gia_ObjIsAnd(pObj) );
-    Gia_ManQuantDupConeSupp_rec( pNew, p, Gia_ObjFanin0(pObj), vCis, vObjs, pFuncCiToKeep, pData );
-    Gia_ManQuantDupConeSupp_rec( pNew, p, Gia_ObjFanin1(pObj), vCis, vObjs, pFuncCiToKeep, pData );
-    iLit0 = Gia_ObjCopyArray( p, Gia_ObjFaninId0(pObj, iObj) );
-    iLit1 = Gia_ObjCopyArray( p, Gia_ObjFaninId1(pObj, iObj) );
-    iLit0 = Abc_LitNotCond( iLit0, Gia_ObjFaninC0(pObj) );
-    iLit1 = Abc_LitNotCond( iLit1, Gia_ObjFaninC1(pObj) );
-    iLit  = Gia_ManHashAnd( pNew, iLit0, iLit1 );
-    Gia_ObjSetCopyArray( p, iObj, iLit );
-    Vec_IntPush( vObjs, iObj );
-}
-Gia_Man_t * Gia_ManQuantDupConeSupp( Gia_Man_t * p, int iLit, int(*pFuncCiToKeep)(void *, int), void * pData, Vec_Int_t ** pvCis, int * pOutLit )
-{
-    Gia_Man_t * pNew; int i, iLit0, iObj;
-    Gia_Obj_t * pObj, * pRoot = Gia_ManObj( p, Abc_Lit2Var(iLit) );
-    Vec_Int_t * vCis = Vec_IntAlloc( 1000 );
-    Vec_Int_t * vObjs = Vec_IntAlloc( 1000 );
-    assert( Gia_ObjIsAnd(pRoot) );
-    if ( Vec_IntSize(&p->vCopies) < Gia_ManObjNum(p) )
-        Vec_IntFillExtra( &p->vCopies, Gia_ManObjNum(p), -1 );
-    pNew = Gia_ManStart( 1000 );
-    Gia_ManHashStart( pNew ); 
-    Gia_ManQuantSetSuppStart( pNew );
-    Gia_ManQuantDupConeSupp_rec( pNew, p, pRoot, vCis, vObjs, pFuncCiToKeep, pData );
-    iLit0 = Gia_ObjCopyArray( p, Abc_Lit2Var(iLit) );
-    iLit0 = Abc_LitNotCond( iLit0, Abc_LitIsCompl(iLit) );
-    if ( pOutLit ) *pOutLit = iLit0;
-    Gia_ManForEachObjVec( vCis, p, pObj, i )
-        Gia_ObjSetCopyArray( p, Gia_ObjId(p, pObj), -1 );
-    Gia_ManForEachObjVec( vObjs, p, pObj, i )
-        Gia_ObjSetCopyArray( p, Gia_ObjId(p, pObj), -1 );
-    //assert( Vec_IntCountLarger(&p->vCopies, -1) == 0 );
-    Vec_IntFree( vObjs );
-    // remap into CI Ids
-    Vec_IntForEachEntry( vCis, iObj, i )
-        Vec_IntWriteEntry( vCis, i, Gia_ManIdToCioId(p, iObj) );
-    if ( pvCis ) *pvCis = vCis;
-    return pNew;
-}
-void Gia_ManQuantExist_rec( Gia_Man_t * p, int iObj, int pRes[2] )
-{
-    Gia_Obj_t * pObj;
-    int Lits0[2], Lits1[2], pFans[2], fCompl[2];
-    if ( Gia_ObjIsTravIdCurrentId( p, iObj ) )
-    {
-        Gia_ObjCopyGetTwoArray( p, iObj, pRes );
-        return;
-    }
-    Gia_ObjSetTravIdCurrentId( p, iObj );
-    pObj = Gia_ManObj( p, iObj );
-    if ( Gia_ObjIsCi(pObj) )
-    {
-        pRes[0] = 0; pRes[1] = 1;
-        Gia_ObjCopySetTwoArray( p, iObj, pRes );
-        return;
-    }
-    pFans[0]  = Gia_ObjFaninId0( pObj, iObj );
-    pFans[1]  = Gia_ObjFaninId1( pObj, iObj );
-    fCompl[0] = Gia_ObjFaninC0( pObj );
-    fCompl[1] = Gia_ObjFaninC1( pObj );
-    if ( Gia_ManQuantCheckSupp(p, pFans[0], p->iSuppPi) )
-        Gia_ManQuantExist_rec( p, pFans[0], Lits0 );
-    else
-        Lits0[0] = Lits0[1] = Abc_Var2Lit( pFans[0], 0 );
-    if ( Gia_ManQuantCheckSupp(p, pFans[1], p->iSuppPi) )
-        Gia_ManQuantExist_rec( p, pFans[1], Lits1 );
-    else
-        Lits1[0] = Lits1[1] = Abc_Var2Lit( pFans[1], 0 );
-    pRes[0] = Gia_ManHashAnd( p, Abc_LitNotCond(Lits0[0], fCompl[0]), Abc_LitNotCond(Lits1[0], fCompl[1]) );
-    pRes[1] = Gia_ManHashAnd( p, Abc_LitNotCond(Lits0[1], fCompl[0]), Abc_LitNotCond(Lits1[1], fCompl[1]) );
-    Gia_ObjCopySetTwoArray( p, iObj, pRes );
-}
-int Gia_ManQuantExist( Gia_Man_t * p0, int iLit, int(*pFuncCiToKeep)(void *, int), void * pData )
-{
-//    abctime clk = Abc_Clock();
-    Gia_Man_t * pNew;
-    Vec_Int_t * vOuts, * vOuts2, * vCis; 
-    Gia_Obj_t * pObj = Gia_ManObj( p0, Abc_Lit2Var(iLit) );
-    int i, n, Entry, Lit, OutLit = -1, pLits[2], nVarsQua, nAndsOld, nAndsNew; 
-    if ( iLit < 2 ) return iLit;
-    if ( Gia_ObjIsCi(pObj) ) return pFuncCiToKeep(pData, Gia_ObjCioId(pObj)) ? iLit : 1;
-    assert( Gia_ObjIsAnd(pObj) );
-    pNew = Gia_ManQuantDupConeSupp( p0, iLit, pFuncCiToKeep, pData, &vCis, &OutLit );
-    if ( pNew->iSuppPi == 0 )
-    {
-        Gia_ManStop( pNew );
-        Vec_IntFree( vCis );
-        return iLit;
-    }
-    assert( pNew->iSuppPi > 0 && pNew->iSuppPi <= 64 * pNew->nSuppWords );
-    vOuts = Vec_IntAlloc( 100 );
-    vOuts2 = Vec_IntAlloc( 100 );
-    assert( OutLit > 1 );
-    Vec_IntPush( vOuts, OutLit );
-    nVarsQua = pNew->iSuppPi;
-    nAndsOld = Gia_ManAndNum(pNew);
-    while ( --pNew->iSuppPi >= 0 )
-    {
-        //printf( "Quantifying input %d:\n", p->iSuppPi );
-        if ( Vec_IntSize(&pNew->vCopiesTwo) < 2*Gia_ManObjNum(pNew) )
-            Vec_IntFillExtra( &pNew->vCopiesTwo, 2*Gia_ManObjNum(pNew), -1 );
-        assert( Vec_IntSize(vOuts) > 0 );
-        Vec_IntClear( vOuts2 );
-        Gia_ManIncrementTravId( pNew );
-        Vec_IntForEachEntry( vOuts, Entry, i )
-        {
-            Gia_ManQuantExist_rec( pNew, Abc_Lit2Var(Entry), pLits );
-            for ( n = 0; n < 2; n++ )
-            {
-                Lit = Abc_LitNotCond( pLits[n], Abc_LitIsCompl(Entry) );
-                if ( Lit == 0 )
-                    continue;
-                if ( Lit == 1 )
-                {
-                    Vec_IntFree( vOuts );
-                    Vec_IntFree( vOuts2 );
-                    Gia_ManStop( pNew );
-                    Vec_IntFree( vCis );
-                    return 1;
-                }
-                Vec_IntPushUnique( vOuts2, Lit );
-            }
-        }
-        Vec_IntClear( vOuts );
-        ABC_SWAP( Vec_Int_t *, vOuts, vOuts2 );
-    }
-    //printf( "The number of diff cofactors = %d.\n", Vec_IntSize(vOuts) );
-    assert( Vec_IntSize(vOuts) > 0 );
-    Vec_IntForEachEntry( vOuts, Entry, i )
-        Vec_IntWriteEntry( vOuts, i, Abc_LitNot(Entry) );
-    OutLit = Gia_ManHashAndMulti( pNew, vOuts );
-    OutLit = Abc_LitNot( OutLit );
-    Vec_IntFree( vOuts );
-    Vec_IntFree( vOuts2 );
-    // transfer back
-    Gia_ManAppendCo( pNew, OutLit );
-    nAndsNew = Gia_ManAndNum(p0);
-    Lit = Gia_ManDupConeBack( p0, pNew, vCis );
-    nAndsNew = Gia_ManAndNum(p0) - nAndsNew;
-    Gia_ManStop( pNew );
-    // report the result
-//    printf( "Performed quantification with %6d nodes, %3d keep-vars, %3d quant-vars, resulting in %5d new nodes. ", 
-//        nAndsOld, Vec_IntSize(vCis) - nVarsQua, nVarsQua, nAndsNew );
-//    Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
-    Vec_IntFree( vCis );
-    return Lit;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates AIG in the DFS order while putting CIs first.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupDfsSkip( Gia_Man_t * p )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i;
-    Gia_ManFillValue( p );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachCi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi(pNew);
-    Gia_ManForEachCo( p, pObj, i )
-        if ( pObj->fMark1 == 0 )
-            Gia_ManDupDfs_rec( pNew, p, pObj );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates AIG in the DFS order while putting CIs first.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupDfsCone( Gia_Man_t * p, Gia_Obj_t * pRoot )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i;
-    assert( Gia_ObjIsCo(pRoot) );
-    Gia_ManFillValue( p );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachCi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi(pNew);
-    Gia_ManDupDfs_rec( pNew, p, Gia_ObjFanin0(pRoot) );
-    Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pRoot) );
-    Gia_ManSetRegNum( pNew, 0 );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates logic cone of the literal and inserts it back.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Gia_ManDupConeSupp_rec( Gia_Man_t * pNew, Gia_Man_t * p, Gia_Obj_t * pObj, Vec_Int_t * vObjs )
-{
-    int iLit0, iLit1, iObj = Gia_ObjId( p, pObj );
-    int iLit = Gia_ObjCopyArray( p, iObj );
-    if ( iLit >= 0 )
-        return;
-    assert( Gia_ObjIsAnd(pObj) );
-    Gia_ManDupConeSupp_rec( pNew, p, Gia_ObjFanin0(pObj), vObjs );
-    Gia_ManDupConeSupp_rec( pNew, p, Gia_ObjFanin1(pObj), vObjs );
-    iLit0 = Gia_ObjCopyArray( p, Gia_ObjFaninId0(pObj, iObj) );
-    iLit1 = Gia_ObjCopyArray( p, Gia_ObjFaninId1(pObj, iObj) );
-    iLit0 = Abc_LitNotCond( iLit0, Gia_ObjFaninC0(pObj) );
-    iLit1 = Abc_LitNotCond( iLit1, Gia_ObjFaninC1(pObj) );
-    iLit  = Gia_ManAppendAnd( pNew, iLit0, iLit1 );
-    Gia_ObjSetCopyArray( p, iObj, iLit );
-    Vec_IntPush( vObjs, iObj );
-}
-Gia_Man_t * Gia_ManDupConeSupp( Gia_Man_t * p, int iLit, Vec_Int_t * vCiIds )
-{
-    Gia_Man_t * pNew; int i, iLit0;
-    Gia_Obj_t * pObj, * pRoot = Gia_ManObj( p, Abc_Lit2Var(iLit) );
-    Vec_Int_t * vObjs = Vec_IntAlloc( 1000 );
-    //assert( Gia_ObjIsAnd(pRoot) );
-    if ( Vec_IntSize(&p->vCopies) < Gia_ManObjNum(p) )
-        Vec_IntFillExtra( &p->vCopies, Gia_ManObjNum(p), -1 );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManForEachCiVec( vCiIds, p, pObj, i )
-        Gia_ObjSetCopyArray( p, Gia_ObjId(p, pObj), Gia_ManAppendCi(pNew) );
-    Gia_ManDupConeSupp_rec( pNew, p, pRoot, vObjs );
-    iLit0 = Gia_ObjCopyArray( p, Abc_Lit2Var(iLit) );
-    iLit0 = Abc_LitNotCond( iLit0, Abc_LitIsCompl(iLit) );
-    Gia_ManAppendCo( pNew, iLit0 );
-    Gia_ManForEachCiVec( vCiIds, p, pObj, i )
-        Gia_ObjSetCopyArray( p, Gia_ObjId(p, pObj), -1 );
-    Gia_ManForEachObjVec( vObjs, p, pObj, i )
-        Gia_ObjSetCopyArray( p, Gia_ObjId(p, pObj), -1 );
-    Vec_IntFree( vObjs );
-    //assert( Vec_IntCountLarger(&p->vCopies, -1) == 0 );
-    return pNew;
-}
-void Gia_ManDupConeBack_rec( Gia_Man_t * pNew, Gia_Man_t * p, Gia_Obj_t * pObj )
-{
-    if ( ~pObj->Value )
-        return;
-    assert( Gia_ObjIsAnd(pObj) );
-    Gia_ManDupConeBack_rec( pNew, p, Gia_ObjFanin0(pObj) );
-    Gia_ManDupConeBack_rec( pNew, p, Gia_ObjFanin1(pObj) );
-    pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-//    pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-}
-int Gia_ManDupConeBack( Gia_Man_t * p, Gia_Man_t * pNew, Vec_Int_t * vCiIds )
-{
-    Gia_Obj_t * pObj, * pRoot; int i;
-    assert( Gia_ManCiNum(pNew) == Vec_IntSize(vCiIds) );
-    Gia_ManFillValue(pNew);
-    Gia_ManConst0(pNew)->Value = 0;
-    Gia_ManForEachCi( pNew, pObj, i )
-        pObj->Value = Gia_Obj2Lit( p, Gia_ManCi(p, Vec_IntEntry(vCiIds, i)) );
-    pRoot = Gia_ManCo(pNew, 0);
-    Gia_ManDupConeBack_rec( p, pNew, Gia_ObjFanin0(pRoot) );
-    return Gia_ObjFanin0Copy(pRoot);
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates AIG in the DFS order while putting CIs first.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Gia_ManDupDfs3_rec( Gia_Man_t * pNew, Gia_Man_t * p, Gia_Obj_t * pObj )
-{
-    if ( ~pObj->Value )
-        return;
-    if ( Gia_ObjIsCi(pObj) )
-    {
-        pObj->Value = Gia_ManAppendCi(pNew);
-        return;
-    }
-    assert( Gia_ObjIsAnd(pObj) );
-    Gia_ManDupDfs3_rec( pNew, p, Gia_ObjFanin0(pObj) );
-    Gia_ManDupDfs3_rec( pNew, p, Gia_ObjFanin1(pObj) );
-    pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-}
-Gia_Man_t * Gia_ManDupDfsNode( Gia_Man_t * p, Gia_Obj_t * pRoot )
-{
-    Gia_Man_t * pNew;
-    assert( Gia_ObjIsAnd(pRoot) );
-    Gia_ManFillValue( p );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManDupDfs3_rec( pNew, p, pRoot );
-    Gia_ManAppendCo( pNew, pRoot->Value );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates AIG in the DFS order while putting CIs first.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupDfsLitArray( Gia_Man_t * p, Vec_Int_t * vLits )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i, iLit, iLitRes;
-    Gia_ManFillValue( p );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachCi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi(pNew);
-    Vec_IntForEachEntry( vLits, iLit, i )
-    {
-        iLitRes = Gia_ManDupDfs2_rec( pNew, p, Gia_ManObj(p, Abc_Lit2Var(iLit)) );
-        Gia_ManAppendCo( pNew, Abc_LitNotCond( iLitRes, Abc_LitIsCompl(iLit)) );
-    }
-    Gia_ManSetRegNum( pNew, 0 );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Returns the array of non-const-0 POs of the dual-output miter.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Int_t * Gia_ManDupTrimmedNonZero( Gia_Man_t * p )
-{
-    Vec_Int_t * vNonZero;
-    Gia_Man_t * pTemp, * pNonDual;
-    Gia_Obj_t * pObj;
-    int i;
-    assert( (Gia_ManPoNum(p) & 1) == 0 );
-    pNonDual = Gia_ManTransformMiter( p );
-    pNonDual = Gia_ManSeqStructSweep( pTemp = pNonDual, 1, 1, 0 );
-    Gia_ManStop( pTemp );
-    assert( Gia_ManPiNum(pNonDual) > 0 );
-    assert( 2 * Gia_ManPoNum(pNonDual) == Gia_ManPoNum(p) );
-    // skip PO pairs corresponding to const0 POs of the non-dual miter
-    vNonZero = Vec_IntAlloc( 100 );
-    Gia_ManForEachPo( pNonDual, pObj, i )
-        if ( !Gia_ObjIsConst0(Gia_ObjFanin0(pObj)) )
-            Vec_IntPush( vNonZero, i );
-    Gia_ManStop( pNonDual );
-    return vNonZero;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Returns 1 if PO can be removed.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Gia_ManPoIsToRemove( Gia_Man_t * p, Gia_Obj_t * pObj, int Value )
-{
-    assert( Gia_ObjIsCo(pObj) );
-    if ( Value == -1 )
-        return Gia_ObjIsConst0(Gia_ObjFanin0(pObj));
-    assert( Value == 0 || Value == 1 );
-    return Gia_ObjIsConst0(Gia_ObjFanin0(pObj)) && Value == Gia_ObjFaninC0(pObj);
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates AIG in the DFS order while putting CIs first.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupTrimmed( Gia_Man_t * p, int fTrimCis, int fTrimCos, int fDualOut, int OutValue )
-{
-    Vec_Int_t * vNonZero = NULL;
-    Gia_Man_t * pNew, * pTemp;
-    Gia_Obj_t * pObj;
-    int i, Entry;
-    // collect non-zero
-    if ( fDualOut && fTrimCos )
-        vNonZero = Gia_ManDupTrimmedNonZero( p );
-    // start new manager
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    // check if there are PIs to be added
-    Gia_ManCreateRefs( p );
-    Gia_ManForEachPi( p, pObj, i )
-        if ( !fTrimCis || Gia_ObjRefNum(p, pObj) )
-            break;
-    if ( i == Gia_ManPiNum(p) ) // there is no PIs - add dummy PI
-        Gia_ManAppendCi(pNew);
-    // add the ROs
-    Gia_ManFillValue( p );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachCi( p, pObj, i )
-        if ( !fTrimCis || Gia_ObjRefNum(p, pObj) || Gia_ObjIsRo(p, pObj) )
-            pObj->Value = Gia_ManAppendCi(pNew);
-    Gia_ManForEachAnd( p, pObj, i )
-        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    if ( fDualOut && fTrimCos )
-    {
-        Vec_IntForEachEntry( vNonZero, Entry, i )
-        {
-            Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(Gia_ManPo(p, 2*Entry+0)) );
-            Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(Gia_ManPo(p, 2*Entry+1)) );
-        }
-        if ( Gia_ManPoNum(pNew) == 0 ) // nothing - add dummy PO
-        {
-//            Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(Gia_ManPo(p, 0)) );
-//            Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(Gia_ManPo(p, 1)) );
-            Gia_ManAppendCo( pNew, 0 );
-            Gia_ManAppendCo( pNew, 0 );
-        }
-        Gia_ManForEachRi( p, pObj, i )
-            Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-        Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-        // cleanup
-        pNew = Gia_ManSeqStructSweep( pTemp = pNew, 1, 1, 0 );
-        Gia_ManStop( pTemp );
-        // trim the PIs
-//        pNew = Gia_ManDupTrimmed( pTemp = pNew, 1, 0, 0 );
-//        Gia_ManStop( pTemp );
-    }
-    else
-    {
-        // check if there are POs to be added
-        Gia_ManForEachPo( p, pObj, i )
-            if ( !fTrimCos || !Gia_ManPoIsToRemove(p, pObj, OutValue) )
-                break;
-        if ( i == Gia_ManPoNum(p) ) // there is no POs - add dummy PO
-            Gia_ManAppendCo( pNew, 0 );
-        Gia_ManForEachCo( p, pObj, i )
-            if ( !fTrimCos || !Gia_ManPoIsToRemove(p, pObj, OutValue) || Gia_ObjIsRi(p, pObj) )
-                Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-        Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    }
-    Vec_IntFreeP( &vNonZero );
-    assert( !Gia_ManHasDangling( pNew ) );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Removes POs driven by PIs and PIs without fanout.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupTrimmed2( Gia_Man_t * p )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i;
-    // start new manager
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    // check if there are PIs to be added
-    Gia_ManCreateRefs( p );
-    // discount references of POs
-    Gia_ManForEachPo( p, pObj, i )
-        Gia_ObjRefFanin0Dec( p, pObj );
-    // check if PIs are left
-    Gia_ManForEachPi( p, pObj, i )
-        if ( Gia_ObjRefNum(p, pObj) )
-            break;
-    if ( i == Gia_ManPiNum(p) ) // there is no PIs - add dummy PI
-        Gia_ManAppendCi(pNew);
-    // add the ROs
-    Gia_ManFillValue( p );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachCi( p, pObj, i )
-        if ( Gia_ObjRefNum(p, pObj) || Gia_ObjIsRo(p, pObj) )
-            pObj->Value = Gia_ManAppendCi(pNew);
-    Gia_ManForEachAnd( p, pObj, i )
-        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    // check if there are POs to be added
-    Gia_ManForEachPo( p, pObj, i )
-        if ( !Gia_ObjIsConst0(Gia_ObjFanin0(pObj)) && !Gia_ObjIsPi(p, Gia_ObjFanin0(pObj)) )
-            break;
-    if ( i == Gia_ManPoNum(p) ) // there is no POs - add dummy PO
-        Gia_ManAppendCo( pNew, 0 );
-    Gia_ManForEachCo( p, pObj, i )
-        if ( (!Gia_ObjIsConst0(Gia_ObjFanin0(pObj)) && !Gia_ObjIsPi(p, Gia_ObjFanin0(pObj))) || Gia_ObjIsRi(p, pObj) )
-            Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    assert( !Gia_ManHasDangling( pNew ) );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates AIG in the DFS order while putting CIs first.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupOntop( Gia_Man_t * p, Gia_Man_t * p2 )
-{
-    Gia_Man_t * pTemp, * pNew;
-    Gia_Obj_t * pObj;
-    int i;
-    assert( Gia_ManPoNum(p) == Gia_ManPiNum(p2) );
-    assert( Gia_ManRegNum(p) == 0 );
-    assert( Gia_ManRegNum(p2) == 0 );
-    pNew = Gia_ManStart( Gia_ManObjNum(p)+Gia_ManObjNum(p2) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManHashAlloc( pNew );
-    // dup first AIG
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachCi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi(pNew);
-    Gia_ManForEachAnd( p, pObj, i )
-        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    // dup second AIG
-    Gia_ManConst0(p2)->Value = 0;
-    Gia_ManForEachCo( p, pObj, i )
-        Gia_ManPi(p2, i)->Value = Gia_ObjFanin0Copy(pObj);
-    Gia_ManForEachAnd( p2, pObj, i )
-        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    Gia_ManForEachCo( p2, pObj, i )
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManHashStop( pNew );
-//    Gia_ManPrintStats( pGiaNew, 0 );
-    pNew = Gia_ManCleanup( pTemp = pNew );
-    Gia_ManStop( pTemp );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates transition relation from p1 and property from p2.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupWithNewPo( Gia_Man_t * p1, Gia_Man_t * p2 )
-{
-    Gia_Man_t * pTemp, * pNew;
-    Gia_Obj_t * pObj;
-    int i;
-    // there is no flops in p2
-    assert( Gia_ManRegNum(p2) == 0 );
-    // there is only one PO in p2
-//    assert( Gia_ManPoNum(p2) == 1 );
-    // input count of p2 is equal to flop count of p1 
-    assert( Gia_ManPiNum(p2) == Gia_ManRegNum(p1) );
-
-    // start new AIG
-    pNew = Gia_ManStart( Gia_ManObjNum(p1)+Gia_ManObjNum(p2) );
-    pNew->pName = Abc_UtilStrsav( p1->pName );
-    pNew->pSpec = Abc_UtilStrsav( p1->pSpec );
-    Gia_ManHashAlloc( pNew );
-    // dup first AIG
-    Gia_ManConst0(p1)->Value = 0;
-    Gia_ManForEachCi( p1, pObj, i )
-        pObj->Value = Gia_ManAppendCi(pNew);
-    Gia_ManForEachAnd( p1, pObj, i )
-        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    // dup second AIG
-    Gia_ManConst0(p2)->Value = 0;
-    Gia_ManForEachPi( p2, pObj, i )
-        pObj->Value = Gia_ManRo(p1, i)->Value;
-    Gia_ManForEachAnd( p2, pObj, i )
-        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    // add property output
-    Gia_ManForEachPo( p2, pObj, i )
-        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    // add flop inputs
-    Gia_ManForEachRi( p1, pObj, i )
-        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManHashStop( pNew );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p1) );
-    pNew = Gia_ManCleanup( pTemp = pNew );
-    Gia_ManStop( pTemp );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Print representatives.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Gia_ManPrintRepr( Gia_Man_t * p )
-{
-    Gia_Obj_t * pObj;
-    int i;
-    Gia_ManForEachObj( p, pObj, i )
-        if ( ~p->pReprsOld[i] )
-            printf( "%d->%d ", i, p->pReprs[i].iRepr );
-    printf( "\n" );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates AIG in the DFS order.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupDfsCiMap( Gia_Man_t * p, int * pCi2Lit, Vec_Int_t * vLits )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i;
-    Gia_ManFillValue( p );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachCi( p, pObj, i )
-    {
-        pObj->Value = Gia_ManAppendCi(pNew);
-        if ( ~pCi2Lit[i] )
-            pObj->Value = Abc_LitNotCond( Gia_ManObj(p, Abc_Lit2Var(pCi2Lit[i]))->Value, Abc_LitIsCompl(pCi2Lit[i]) );
-    }
-    Gia_ManHashAlloc( pNew );
-    if ( vLits )
-    {
-        int iLit, iLitRes;
-        Vec_IntForEachEntry( vLits, iLit, i )
-        {
-            iLitRes = Gia_ManDupDfs2_rec( pNew, p, Gia_ManObj(p, Abc_Lit2Var(iLit)) );
-            Gia_ManAppendCo( pNew, Abc_LitNotCond( iLitRes, Abc_LitIsCompl(iLit)) );
-        }
-    }
-    else
-    {
-        Gia_ManForEachCo( p, pObj, i )
-        {
-            Gia_ManDupDfs2_rec( pNew, p, Gia_ObjFanin0(pObj) );
-            Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-        }
-    }
-    Gia_ManHashStop( pNew );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Permute inputs.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManPermuteInputs( Gia_Man_t * p, int nPpis, int nExtra )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i;
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    for ( i = 0; i < Gia_ManPiNum(p) - nPpis - nExtra; i++ ) // regular PIs
-        Gia_ManCi(p, i)->Value = Gia_ManAppendCi( pNew );
-    for ( i = Gia_ManPiNum(p) - nExtra; i < Gia_ManPiNum(p); i++ ) // extra PIs due to DC values
-        Gia_ManCi(p, i)->Value = Gia_ManAppendCi( pNew );
-    for ( i = Gia_ManPiNum(p) - nPpis - nExtra; i < Gia_ManPiNum(p) - nExtra; i++ ) // pseudo-PIs
-        Gia_ManCi(p, i)->Value = Gia_ManAppendCi( pNew );
-    for ( i = Gia_ManPiNum(p); i < Gia_ManCiNum(p); i++ ) // flop outputs
-        Gia_ManCi(p, i)->Value = Gia_ManAppendCi( pNew );
-    assert( Gia_ManCiNum(pNew) == Gia_ManCiNum(p) );
-    Gia_ManForEachAnd( p, pObj, i )
-        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    Gia_ManForEachCo( p, pObj, i )
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates AIG in the DFS order.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupDfsClasses( Gia_Man_t * p )
-{
-    Gia_Man_t * pNew, * pTemp;
-    Gia_Obj_t * pObj;
-    int i;
-    assert( p->pReprsOld != NULL );
-    Gia_ManFillValue( p );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachCi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi(pNew);
-    Gia_ManHashAlloc( pNew );
-    Gia_ManForEachCo( p, pObj, i )
-        Gia_ManDupDfs_rec( pNew, p, pObj );
-    Gia_ManHashStop( pNew );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    pNew = Gia_ManCleanup( pTemp = pNew );
-    Gia_ManStop( pTemp );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Detect topmost gate.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupTopAnd_iter( Gia_Man_t * p, int fVerbose )  
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    Vec_Int_t * vFront, * vLeaves;
-    int i, iLit, iObjId, nCiLits, * pCi2Lit;
-    char * pVar2Val;
-    // collect the frontier
-    vFront = Vec_IntAlloc( 1000 );
-    vLeaves = Vec_IntAlloc( 1000 );
-    Gia_ManForEachCo( p, pObj, i )
-    {
-        if ( Gia_ObjIsConst0( Gia_ObjFanin0(pObj) ) )
-            continue;
-        if ( Gia_ObjFaninC0(pObj) )
-            Vec_IntPush( vLeaves, Gia_ObjFaninLit0p(p, pObj) );
-        else
-            Vec_IntPush( vFront, Gia_ObjFaninId0p(p, pObj) );
-    }
-    if ( Vec_IntSize(vFront) == 0 )
-    {
-        if ( fVerbose )
-            printf( "The AIG cannot be decomposed using AND-decomposition.\n" );
-        Vec_IntFree( vFront );
-        Vec_IntFree( vLeaves );
-        return Gia_ManDupNormalize( p, 0 );
-    }
-    // expand the frontier
-    Gia_ManForEachObjVec( vFront, p, pObj, i )
-    {
-        if ( Gia_ObjIsCi(pObj) )
-        {
-            Vec_IntPush( vLeaves, Abc_Var2Lit( Gia_ObjId(p, pObj), 0 ) );
-            continue;
-        }
-        assert( Gia_ObjIsAnd(pObj) );
-        if ( Gia_ObjFaninC0(pObj) )
-            Vec_IntPush( vLeaves, Gia_ObjFaninLit0p(p, pObj) );
-        else
-            Vec_IntPush( vFront, Gia_ObjFaninId0p(p, pObj) );
-        if ( Gia_ObjFaninC1(pObj) )
-            Vec_IntPush( vLeaves, Gia_ObjFaninLit1p(p, pObj) );
-        else
-            Vec_IntPush( vFront, Gia_ObjFaninId1p(p, pObj) );
-    }
-    Vec_IntFree( vFront );
-    // sort the literals
-    nCiLits = 0;
-    pCi2Lit = ABC_FALLOC( int, Gia_ManObjNum(p) );
-    pVar2Val = ABC_FALLOC( char, Gia_ManObjNum(p) );
-    Vec_IntForEachEntry( vLeaves, iLit, i )
-    {
-        iObjId = Abc_Lit2Var(iLit);
-        pObj = Gia_ManObj(p, iObjId);
-        if ( Gia_ObjIsCi(pObj) )
-        {
-            pCi2Lit[Gia_ObjCioId(pObj)] = !Abc_LitIsCompl(iLit);
-            nCiLits++;
-        }
-        if ( pVar2Val[iObjId] != 0 && pVar2Val[iObjId] != 1 )
-            pVar2Val[iObjId] = Abc_LitIsCompl(iLit);
-        else if ( pVar2Val[iObjId] != Abc_LitIsCompl(iLit) )
-            break;
-    }
-    if ( i < Vec_IntSize(vLeaves) )
-    {
-        printf( "Problem is trivially UNSAT.\n" );
-        ABC_FREE( pCi2Lit );
-        ABC_FREE( pVar2Val );
-        Vec_IntFree( vLeaves );
-        return Gia_ManDupNormalize( p, 0 );
-    }
-    // create array of input literals
-    Vec_IntClear( vLeaves );
-    Gia_ManForEachObj( p, pObj, i )
-        if ( !Gia_ObjIsCi(pObj) && (pVar2Val[i] == 0 || pVar2Val[i] == 1) )
-            Vec_IntPush( vLeaves, Abc_Var2Lit(i, pVar2Val[i]) );
-    if ( fVerbose )
-        printf( "Detected %6d AND leaves and %6d CI leaves.\n", Vec_IntSize(vLeaves), nCiLits );
-    // create the input map
-    if ( nCiLits == 0 )
-        pNew = Gia_ManDupDfsLitArray( p, vLeaves );
-    else
-        pNew = Gia_ManDupDfsCiMap( p, pCi2Lit, vLeaves );
-    ABC_FREE( pCi2Lit );
-    ABC_FREE( pVar2Val );
-    Vec_IntFree( vLeaves );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Detect topmost gate.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupTopAnd( Gia_Man_t * p, int fVerbose )  
-{
-    Gia_Man_t * pNew, * pTemp;
-    int fContinue, iIter = 0;
-    pNew = Gia_ManDupNormalize( p, 0 );
-    for ( fContinue = 1; fContinue; )
-    {
-        pNew = Gia_ManDupTopAnd_iter( pTemp = pNew, fVerbose );
-        if ( Gia_ManCoNum(pNew) == Gia_ManCoNum(pTemp) && Gia_ManAndNum(pNew) == Gia_ManAndNum(pTemp) )
-            fContinue = 0;
-        Gia_ManStop( pTemp );
-        if ( fVerbose )
-        {
-            printf( "Iter %2d : ", ++iIter );
-            Gia_ManPrintStatsShort( pNew );
-        }
-    }
-    return pNew;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates the AIG in the DFS order.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Gia_ManMiter_rec( Gia_Man_t * pNew, Gia_Man_t * p, Gia_Obj_t * pObj )
-{
-    if ( ~pObj->Value )
-        return pObj->Value;
-    assert( Gia_ObjIsAnd(pObj) );
-    Gia_ManMiter_rec( pNew, p, Gia_ObjFanin0(pObj) );
-    Gia_ManMiter_rec( pNew, p, Gia_ObjFanin1(pObj) );
-    return pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Creates miter of two designs.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManMiter( Gia_Man_t * p0, Gia_Man_t * p1, int nInsDup, int fDualOut, int fSeq, int fImplic, int fVerbose )
-{
-    Gia_Man_t * pNew, * pTemp;
-    Gia_Obj_t * pObj;
-    int i, iLit;
-    if ( fSeq )
-    {
-        if ( Gia_ManPiNum(p0) != Gia_ManPiNum(p1) )
-        {
-            printf( "Gia_ManMiter(): Designs have different number of PIs.\n" );
-            return NULL;
-        }
-        if ( Gia_ManPoNum(p0) != Gia_ManPoNum(p1) )
-        {
-            printf( "Gia_ManMiter(): Designs have different number of POs.\n" );
-            return NULL;
-        }
-        if ( Gia_ManRegNum(p0) == 0 || Gia_ManRegNum(p1) == 0 )
-        {
-            printf( "Gia_ManMiter(): At least one of the designs has no registers.\n" );
-            return NULL;
-        }
-    }
-    else
-    {
-        if ( Gia_ManCiNum(p0) != Gia_ManCiNum(p1) )
-        {
-            printf( "Gia_ManMiter(): Designs have different number of CIs.\n" );
-            return NULL;
-        }
-        if ( Gia_ManCoNum(p0) != Gia_ManCoNum(p1) )
-        {
-            printf( "Gia_ManMiter(): Designs have different number of COs.\n" );
-            return NULL;
-        }
-    }
-    // start the manager
-    pNew = Gia_ManStart( Gia_ManObjNum(p0) + Gia_ManObjNum(p1) );
-    pNew->pName = Abc_UtilStrsav( "miter" );
-    // map combinational inputs
-    Gia_ManFillValue( p0 );
-    Gia_ManFillValue( p1 );
-    Gia_ManConst0(p0)->Value = 0;
-    Gia_ManConst0(p1)->Value = 0;
-    // map internal nodes and outputs
-    Gia_ManHashAlloc( pNew );
-    if ( fSeq )
-    {
-        // create primary inputs
-        Gia_ManForEachPi( p0, pObj, i )
-            pObj->Value = Gia_ManAppendCi( pNew );
-        Gia_ManForEachPi( p1, pObj, i )
-            if ( i < Gia_ManPiNum(p1) - nInsDup )
-                pObj->Value = Gia_ObjToLit( pNew, Gia_ManPi(pNew, i) );
-            else
-                pObj->Value = Gia_ManAppendCi( pNew );
-        // create latch outputs
-        Gia_ManForEachRo( p0, pObj, i )
-            pObj->Value = Gia_ManAppendCi( pNew );
-        Gia_ManForEachRo( p1, pObj, i )
-            pObj->Value = Gia_ManAppendCi( pNew );
-        // create primary outputs
-        Gia_ManForEachPo( p0, pObj, i )
-        {
-            Gia_ManMiter_rec( pNew, p0, Gia_ObjFanin0(pObj) );
-            Gia_ManMiter_rec( pNew, p1, Gia_ObjFanin0(Gia_ManPo(p1,i)) );
-            if ( fDualOut )
-            {
-                Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-                Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(Gia_ManPo(p1,i)) );
-            }
-            else if ( fImplic )
-            {
-                iLit = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Abc_LitNot(Gia_ObjFanin0Copy(Gia_ManPo(p1,i))) );
-                Gia_ManAppendCo( pNew, iLit );
-            }
-            else 
-            {
-                iLit = Gia_ManHashXor( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin0Copy(Gia_ManPo(p1,i)) );
-                Gia_ManAppendCo( pNew, iLit );
-            }
-        }
-        // create register inputs
-        Gia_ManForEachRi( p0, pObj, i )
-        {
-            Gia_ManMiter_rec( pNew, p0, Gia_ObjFanin0(pObj) );
-            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-        }
-        Gia_ManForEachRi( p1, pObj, i )
-        {
-            Gia_ManMiter_rec( pNew, p1, Gia_ObjFanin0(pObj) );
-            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-        }
-        Gia_ManSetRegNum( pNew, Gia_ManRegNum(p0) + Gia_ManRegNum(p1) );
-    }
-    else
-    {
-        // create combinational inputs
-        Gia_ManForEachCi( p0, pObj, i )
-            pObj->Value = Gia_ManAppendCi( pNew );
-        Gia_ManForEachCi( p1, pObj, i )
-            if ( i < Gia_ManCiNum(p1) - nInsDup )
-                pObj->Value = Gia_ObjToLit( pNew, Gia_ManCi(pNew, i) );
-            else
-                pObj->Value = Gia_ManAppendCi( pNew );
-        // create combinational outputs
-        Gia_ManForEachCo( p0, pObj, i )
-        {
-            Gia_ManMiter_rec( pNew, p0, Gia_ObjFanin0(pObj) );
-            Gia_ManMiter_rec( pNew, p1, Gia_ObjFanin0(Gia_ManCo(p1,i)) );
-            if ( fDualOut )
-            {
-                Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-                Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(Gia_ManCo(p1,i)) );
-            }
-            else if ( fImplic )
-            {
-                iLit = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Abc_LitNot(Gia_ObjFanin0Copy(Gia_ManPo(p1,i))) );
-                Gia_ManAppendCo( pNew, iLit );
-            }
-            else
-            {
-                iLit = Gia_ManHashXor( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin0Copy(Gia_ManCo(p1,i)) );
-                Gia_ManAppendCo( pNew, iLit );
-            }
-        }
-    }
-    Gia_ManHashStop( pNew );
-    pNew = Gia_ManCleanup( pTemp = pNew );
-    Gia_ManStop( pTemp );
-
-    pNew = Gia_ManDupNormalize( pTemp = pNew, 0 );
-    Gia_ManStop( pTemp );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Computes the AND of all POs.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupAndOr( Gia_Man_t * p, int nOuts, int fUseOr, int fCompl )
-{
-    Gia_Man_t * pNew, * pTemp;
-    Gia_Obj_t * pObj;
-    int i, iResult;
-    assert( Gia_ManRegNum(p) == 0 );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManHashAlloc( pNew );
-    Gia_ManForEachPi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi( pNew );
-    Gia_ManForEachAnd( p, pObj, i )
-        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    if ( fUseOr ) // construct OR of all POs
-    {
-        iResult = 0;
-        Gia_ManForEachPo( p, pObj, i )
-            iResult = Gia_ManHashOr( pNew, iResult, Gia_ObjFanin0Copy(pObj) );
-    }
-    else // construct AND of all POs
-    {
-        iResult = 1;
-        Gia_ManForEachPo( p, pObj, i )
-            iResult = Gia_ManHashAnd( pNew, iResult, Gia_ObjFanin0Copy(pObj) );
-    }
-    iResult = Abc_LitNotCond( iResult, (int)(fCompl > 0) );
-//    Gia_ManForEachPo( p, pObj, i )
-//        pObj->Value = Gia_ManAppendCo( pNew, iResult );
-    for ( i = 0; i < nOuts; i++ )
-        Gia_ManAppendCo( pNew, iResult );
-    Gia_ManHashStop( pNew );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    pNew = Gia_ManCleanup( pTemp = pNew );
-    Gia_ManStop( pTemp );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Transforms the circuit into a regular miter.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManTransformMiter( Gia_Man_t * p )
-{
-    Gia_Man_t * pNew, * pTemp;
-    Gia_Obj_t * pObj, * pObj2;
-    int i, iLit;
-    assert( (Gia_ManPoNum(p) & 1) == 0 );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManHashAlloc( pNew );
-    Gia_ManForEachCi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi( pNew );
-    Gia_ManForEachAnd( p, pObj, i )
-        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    Gia_ManForEachPo( p, pObj, i )
-    {
-        pObj2 = Gia_ManPo( p, ++i );
-        iLit = Gia_ManHashXor( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin0Copy(pObj2) );
-        Gia_ManAppendCo( pNew, iLit );
-    }
-    Gia_ManForEachRi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManHashStop( pNew );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    pNew = Gia_ManCleanup( pTemp = pNew );
-    Gia_ManStop( pTemp );
-    return pNew;
-}
-Gia_Man_t * Gia_ManTransformMiter2( Gia_Man_t * p )
-{
-    Gia_Man_t * pNew, * pTemp;
-    Gia_Obj_t * pObj, * pObj2;
-    int i, iLit, nPart = Gia_ManPoNum(p)/2;
-    assert( (Gia_ManPoNum(p) & 1) == 0 );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManHashAlloc( pNew );
-    Gia_ManForEachCi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi( pNew );
-    Gia_ManForEachAnd( p, pObj, i )
-        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    Gia_ManForEachPo( p, pObj, i )
-    {
-        if ( i == nPart )
-            break;
-        pObj2 = Gia_ManPo( p, nPart + i );
-        iLit = Gia_ManHashXor( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin0Copy(pObj2) );
-        Gia_ManAppendCo( pNew, iLit );
-    }
-    Gia_ManForEachRi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManHashStop( pNew );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    pNew = Gia_ManCleanup( pTemp = pNew );
-    Gia_ManStop( pTemp );
-    return pNew;
-}
-Gia_Man_t * Gia_ManTransformToDual( Gia_Man_t * p )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i;
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManHashAlloc( pNew );
-    Gia_ManForEachCi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi( pNew );
-    Gia_ManForEachAnd( p, pObj, i )
-        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    Gia_ManForEachPo( p, pObj, i )
-    {
-        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-        Gia_ManAppendCo( pNew, 0 );
-    }
-    Gia_ManForEachRi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManHashStop( pNew );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    return pNew;
-}
-Gia_Man_t * Gia_ManTransformTwoWord2DualOutput( Gia_Man_t * p )
-{
-    Gia_Man_t * pNew, * pTemp;
-    Gia_Obj_t * pObj, * pObj2;
-    int i, nPart = Gia_ManPoNum(p)/2;
-    assert( (Gia_ManPoNum(p) & 1) == 0 );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManHashAlloc( pNew );
-    Gia_ManForEachCi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi( pNew );
-    Gia_ManForEachAnd( p, pObj, i )
-        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    Gia_ManForEachPo( p, pObj, i )
-    {
-        if ( i == nPart )
-            break;
-        pObj2 = Gia_ManPo( p, nPart + i );
-        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj2) );
-    }
-    Gia_ManForEachRi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManHashStop( pNew );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    pNew = Gia_ManCleanup( pTemp = pNew );
-    Gia_ManStop( pTemp );
-    return pNew;
-}
-
-void Gia_ManCollectOneSide_rec( Gia_Man_t * p, Gia_Obj_t * pObj, Vec_Int_t * vNodes )
-{
-    if ( Gia_ObjIsTravIdCurrent(p, pObj) )
-        return;
-    Gia_ObjSetTravIdCurrent(p, pObj);
-    if ( !Gia_ObjIsAnd(pObj) )
-        return;
-    Gia_ManCollectOneSide_rec( p, Gia_ObjFanin0(pObj), vNodes );
-    Gia_ManCollectOneSide_rec( p, Gia_ObjFanin1(pObj), vNodes );
-    Vec_IntPush( vNodes, Gia_ObjId(p, pObj) );
-}
-Vec_Int_t * Gia_ManCollectOneSide( Gia_Man_t * p, int iSide )
-{
-    Gia_Obj_t * pObj; int i;
-    Vec_Int_t * vNodes = Vec_IntAlloc( Gia_ManAndNum(p) );
-    Gia_ManIncrementTravId( p );
-    Gia_ManForEachPo( p, pObj, i )
-        if ( (i & 1) == iSide )
-            Gia_ManCollectOneSide_rec( p, Gia_ObjFanin0(pObj), vNodes );
-    return vNodes;
-}
-Gia_Man_t * Gia_ManTransformDualOutput( Gia_Man_t * p )
-{
-    Vec_Int_t * vNodes0 = Gia_ManCollectOneSide( p, 0 );
-    Vec_Int_t * vNodes1 = Gia_ManCollectOneSide( p, 1 );
-    Gia_Man_t * pNew, * pTemp;
-    Gia_Obj_t * pObj, * pObj2;
-    int i, fSwap = 0;
-    assert( Gia_ManRegNum(p) == 0 );
-    assert( (Gia_ManPoNum(p) & 1) == 0 );
-    if ( Vec_IntSize(vNodes0) > Vec_IntSize(vNodes1) )
-    {
-        ABC_SWAP( Vec_Int_t *, vNodes0, vNodes1 );
-        fSwap = 1;
-    }
-    assert( Vec_IntSize(vNodes0) <= Vec_IntSize(vNodes1) );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManHashAlloc( pNew );
-    Gia_ManForEachCi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi( pNew );
-    Gia_ManForEachObjVec( vNodes0, p, pObj, i )
-        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    Gia_ManForEachObjVec( vNodes1, p, pObj, i )
-        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    Vec_IntFree( vNodes0 );
-    Vec_IntFree( vNodes1 );
-    Gia_ManForEachPo( p, pObj, i )
-    {
-        pObj2 = Gia_ManPo( p, i^fSwap );
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj2) );
-    }
-    Gia_ManHashStop( pNew );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    pNew = Gia_ManCleanup( pTemp = pNew );
-    Gia_ManStop( pTemp );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Performs 'zero' and 'undc' operation.]
-
-  Description [The init string specifies 0/1/X for each flop.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupZeroUndc( Gia_Man_t * p, char * pInit, int fGiaSimple, int fVerbose )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int CountPis = Gia_ManPiNum(p), * pPiLits;
-    int i, iResetFlop = -1, Count1 = 0;
-    //printf( "Using %s\n", pInit );
-    // map X-valued flops into new PIs
-    assert( (int)strlen(pInit) == Gia_ManRegNum(p) );
-    pPiLits = ABC_FALLOC( int, Gia_ManRegNum(p) );
-    for ( i = 0; i < Gia_ManRegNum(p); i++ )
-        if ( pInit[i] == 'x' || pInit[i] == 'X' )
-            pPiLits[i] = CountPis++;
-    // create new manager
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    pNew->fGiaSimple = fGiaSimple;
-    Gia_ManConst0(p)->Value = 0;
-    // create primary inputs
-    Gia_ManForEachPi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi( pNew );
-    // create additional primary inputs
-    for ( i = Gia_ManPiNum(p); i < CountPis; i++ )
-        Gia_ManAppendCi( pNew );
-    // create flop outputs
-    Gia_ManForEachRo( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi( pNew );
-    // create reset flop output
-    if ( CountPis > Gia_ManPiNum(p) )
-        iResetFlop = Gia_ManAppendCi( pNew );
-    // update flop outputs
-    Gia_ManMarkFanoutDrivers( p );
-    Gia_ManForEachRo( p, pObj, i )
-    {
-        if ( pInit[i] == '1' )
-            pObj->Value = Abc_LitNot(pObj->Value), Count1++;
-        else if ( pInit[i] == 'x' || pInit[i] == 'X' )
-        {
-            if ( pObj->fMark0 ) // only add MUX if the flop has fanout
-                pObj->Value = Gia_ManAppendMux( pNew, iResetFlop, pObj->Value, Gia_Obj2Lit(pNew, Gia_ManPi(pNew, pPiLits[i])) );
-        }
-        else if ( pInit[i] != '0' )
-            assert( 0 );
-    }
-    Gia_ManCleanMark0( p );
-    ABC_FREE( pPiLits );
-    // build internal nodes
-    Gia_ManForEachAnd( p, pObj, i )
-        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    // create POs
-    Gia_ManForEachPo( p, pObj, i )
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    // create flop inputs
-    Gia_ManForEachRi( p, pObj, i )
-        if ( pInit[i] == '1' )
-            pObj->Value = Gia_ManAppendCo( pNew, Abc_LitNot(Gia_ObjFanin0Copy(pObj)) );
-        else
-            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    // create reset flop input
-    if ( CountPis > Gia_ManPiNum(p) )
-        Gia_ManAppendCo( pNew, 1 );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) + (int)(CountPis > Gia_ManPiNum(p)) );
-    if ( fVerbose )
-        printf( "Converted %d 1-valued FFs and %d DC-valued FFs.\n", Count1, CountPis-Gia_ManPiNum(p) );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Creates miter of two designs.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManMiter2( Gia_Man_t * pStart, char * pInit, int fVerbose )
-{
-    Vec_Int_t * vCiValues, * vCoValues0, * vCoValues1;
-    Gia_Man_t * pNew, * pUndc, * pTemp;
-    Gia_Obj_t * pObj;
-    char * pInitNew;
-    int i, k;
-    // check PI values
-    for ( i = 0; i < Gia_ManPiNum(pStart); i++ )
-        assert( pInit[i] == 'x' || pInit[i] == 'X' );
-    // normalize the manager
-    pUndc = Gia_ManDupZeroUndc( pStart, pInit + Gia_ManPiNum(pStart), 0, fVerbose );
-    // create new init string
-    pInitNew = ABC_ALLOC( char, Gia_ManPiNum(pUndc)+1 );
-    for ( i = 0; i < Gia_ManPiNum(pStart); i++ )
-        pInitNew[i] = pInit[i];
-    for ( i = k = Gia_ManPiNum(pStart); i < Gia_ManCiNum(pStart); i++ )
-        if ( pInit[i] == 'x' || pInit[i] == 'X' )
-            pInitNew[k++] = pInit[i];
-    pInitNew[k] = 0;
-    assert( k == Gia_ManPiNum(pUndc) );
-    // derive miter
-    pNew = Gia_ManStart( Gia_ManObjNum(pUndc) );
-    pNew->pName = Abc_UtilStrsav( pUndc->pName );
-    pNew->pSpec = Abc_UtilStrsav( pUndc->pSpec );
-    Gia_ManConst0(pUndc)->Value = 0;
-    Gia_ManHashAlloc( pNew );
-    // add PIs of the first side
-    Gia_ManForEachPi( pUndc, pObj, i )
-        pObj->Value = Gia_ManAppendCi( pNew );
-    // add PIs of the second side
-    vCiValues = Vec_IntAlloc( Gia_ManPiNum(pUndc) );
-    Gia_ManForEachPi( pUndc, pObj, i )
-        if ( pInitNew[i] == 'x' )
-            Vec_IntPush( vCiValues, Gia_Obj2Lit( pNew, Gia_ManPi(pNew, i) ) );
-        else if ( pInitNew[i] == 'X' ) 
-            Vec_IntPush( vCiValues, Gia_ManAppendCi( pNew ) );
-        else assert( 0 );
-    // build flops and internal nodes
-    Gia_ManForEachRo( pUndc, pObj, i )
-        pObj->Value = Gia_ManAppendCi( pNew );
-    Gia_ManForEachAnd( pUndc, pObj, i )
-        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    // collect CO values
-    vCoValues0 = Vec_IntAlloc( Gia_ManPoNum(pUndc) );
-    Gia_ManForEachCo( pUndc, pObj, i )
-        Vec_IntPush( vCoValues0, Gia_ObjFanin0Copy(pObj) );
-    // build the other side
-    Gia_ManForEachPi( pUndc, pObj, i )
-        pObj->Value = Vec_IntEntry( vCiValues, i );
-    Gia_ManForEachRo( pUndc, pObj, i )
-        pObj->Value = Gia_ManAppendCi( pNew );
-    Gia_ManForEachAnd( pUndc, pObj, i )
-        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    // collect CO values
-    vCoValues1 = Vec_IntAlloc( Gia_ManPoNum(pUndc) );
-    Gia_ManForEachCo( pUndc, pObj, i )
-        Vec_IntPush( vCoValues1, Gia_ObjFanin0Copy(pObj) );
-    // create POs
-    Gia_ManForEachPo( pUndc, pObj, i )
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ManHashXor( pNew, Vec_IntEntry(vCoValues0, i), Vec_IntEntry(vCoValues1, i) ) );
-    // create flop inputs
-    Gia_ManForEachRi( pUndc, pObj, i )
-        pObj->Value = Gia_ManAppendCo( pNew, Vec_IntEntry(vCoValues0, Gia_ManPoNum(pUndc)+i) );
-    Gia_ManForEachRi( pUndc, pObj, i )
-        pObj->Value = Gia_ManAppendCo( pNew, Vec_IntEntry(vCoValues1, Gia_ManPoNum(pUndc)+i) );
-    Vec_IntFree( vCoValues0 );
-    Vec_IntFree( vCoValues1 );
-    Vec_IntFree( vCiValues );
-    ABC_FREE( pInitNew );
-    // cleanup
-    Gia_ManHashStop( pNew );
-    Gia_ManSetRegNum( pNew, 2*Gia_ManRegNum(pUndc) );
-    Gia_ManStop( pUndc );
-    pNew = Gia_ManCleanup( pTemp = pNew );
-    Gia_ManStop( pTemp );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates the AIG in the DFS order.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Gia_ManChoiceMiter_rec( Gia_Man_t * pNew, Gia_Man_t * p, Gia_Obj_t * pObj )
-{
-    if ( ~pObj->Value )
-        return pObj->Value;
-    Gia_ManChoiceMiter_rec( pNew, p, Gia_ObjFanin0(pObj) );
-    if ( Gia_ObjIsCo(pObj) )
-        return pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManChoiceMiter_rec( pNew, p, Gia_ObjFanin1(pObj) );
-    return pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-} 
-
-/**Function*************************************************************
-
-  Synopsis    [Derives the miter of several AIGs for choice computation.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManChoiceMiter( Vec_Ptr_t * vGias )
-{
-    Gia_Man_t * pNew, * pGia, * pGia0;
-    int i, k, iNode, nNodes;
-    // make sure they have equal parameters
-    assert( Vec_PtrSize(vGias) > 0 );
-    pGia0 = (Gia_Man_t *)Vec_PtrEntry( vGias, 0 );
-    Vec_PtrForEachEntry( Gia_Man_t *, vGias, pGia, i )
-    {
-        assert( Gia_ManCiNum(pGia)  == Gia_ManCiNum(pGia0) );
-        assert( Gia_ManCoNum(pGia)  == Gia_ManCoNum(pGia0) );
-        assert( Gia_ManRegNum(pGia) == Gia_ManRegNum(pGia0) );
-        Gia_ManFillValue( pGia );
-        Gia_ManConst0(pGia)->Value = 0;
-    }
-    // start the new manager
-    pNew = Gia_ManStart( Vec_PtrSize(vGias) * Gia_ManObjNum(pGia0) );
-    pNew->pName = Abc_UtilStrsav( pGia0->pName );
-    pNew->pSpec = Abc_UtilStrsav( pGia0->pSpec );
-    // create new CIs and assign them to the old manager CIs
-    for ( k = 0; k < Gia_ManCiNum(pGia0); k++ )
-    {
-        iNode = Gia_ManAppendCi(pNew);
-        Vec_PtrForEachEntry( Gia_Man_t *, vGias, pGia, i )
-            Gia_ManCi( pGia, k )->Value = iNode; 
-    }
-    // create internal nodes
-    Gia_ManHashAlloc( pNew );
-    for ( k = 0; k < Gia_ManCoNum(pGia0); k++ )
-    {
-        Vec_PtrForEachEntry( Gia_Man_t *, vGias, pGia, i )
-            Gia_ManChoiceMiter_rec( pNew, pGia, Gia_ManCo( pGia, k ) );
-    }
-    Gia_ManHashStop( pNew );
-    // check the presence of dangling nodes
-    nNodes = Gia_ManHasDangling( pNew );
-    //assert( nNodes == 0 );
-    // finalize
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(pGia0) );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates AIG while putting first PIs, then nodes, then POs.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupWithConstraints( Gia_Man_t * p, Vec_Int_t * vPoTypes )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i, nConstr = 0;
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachCi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi(pNew);
-    Gia_ManForEachAnd( p, pObj, i )
-        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    Gia_ManForEachPo( p, pObj, i )
-        if ( Vec_IntEntry(vPoTypes, i) == 0 ) // regular PO
-            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManForEachPo( p, pObj, i )
-        if ( Vec_IntEntry(vPoTypes, i) == 1 ) // constraint (should be complemented!)
-            pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) ^ 1 ), nConstr++;
-    Gia_ManForEachRi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-//    Gia_ManDupRemapEquiv( pNew, p );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    pNew->nConstrs = nConstr;
-    assert( Gia_ManIsNormalized(pNew) );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Copy an AIG structure related to the selected POs.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Gia_ObjCompareByCioId( Gia_Obj_t ** pp1, Gia_Obj_t ** pp2 )
-{
-    Gia_Obj_t * pObj1 = *pp1;
-    Gia_Obj_t * pObj2 = *pp2;
-    return Gia_ObjCioId(pObj1) - Gia_ObjCioId(pObj2);
-}
-void Gia_ManDupCones_rec( Gia_Man_t * p, Gia_Obj_t * pObj, Vec_Ptr_t * vLeaves, Vec_Ptr_t * vNodes, Vec_Ptr_t * vRoots )
-{
-    if ( Gia_ObjIsTravIdCurrent(p, pObj) )
-        return;
-    Gia_ObjSetTravIdCurrent(p, pObj);
-    if ( Gia_ObjIsAnd(pObj) )
-    {
-        Gia_ManDupCones_rec( p, Gia_ObjFanin0(pObj), vLeaves, vNodes, vRoots );
-        Gia_ManDupCones_rec( p, Gia_ObjFanin1(pObj), vLeaves, vNodes, vRoots );
-        Vec_PtrPush( vNodes, pObj );
-    }
-    else if ( Gia_ObjIsCo(pObj) )
-        Gia_ManDupCones_rec( p, Gia_ObjFanin0(pObj), vLeaves, vNodes, vRoots );
-    else if ( Gia_ObjIsRo(p, pObj) )
-        Vec_PtrPush( vRoots, Gia_ObjRoToRi(p, pObj) );
-    else if ( Gia_ObjIsPi(p, pObj) )
-        Vec_PtrPush( vLeaves, pObj );
-    else assert( 0 );
-}
-Gia_Man_t * Gia_ManDupCones( Gia_Man_t * p, int * pPos, int nPos, int fTrimPis )
-{
-    Gia_Man_t * pNew;
-    Vec_Ptr_t * vLeaves, * vNodes, * vRoots;
-    Gia_Obj_t * pObj;
-    int i;
-
-    // collect initial POs
-    vLeaves = Vec_PtrAlloc( 100 );
-    vNodes = Vec_PtrAlloc( 100 );
-    vRoots = Vec_PtrAlloc( 100 );
-    for ( i = 0; i < nPos; i++ )
-        Vec_PtrPush( vRoots, Gia_ManPo(p, pPos[i]) );
-
-    // mark internal nodes
-    Gia_ManIncrementTravId( p );
-    Gia_ObjSetTravIdCurrent( p, Gia_ManConst0(p) );
-    Vec_PtrForEachEntry( Gia_Obj_t *, vRoots, pObj, i )
-        Gia_ManDupCones_rec( p, pObj, vLeaves, vNodes, vRoots );
-    Vec_PtrSort( vLeaves, (int (*)(void))Gia_ObjCompareByCioId );
-
-    // start the new manager
-//    Gia_ManFillValue( p );
-    pNew = Gia_ManStart( (fTrimPis ? Vec_PtrSize(vLeaves) : Gia_ManCiNum(p)) + Vec_PtrSize(vNodes) + Vec_PtrSize(vRoots) + 1 );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    // map the constant node
-    Gia_ManConst0(p)->Value = 0;
-    // create PIs
-    if ( fTrimPis )
-    {
-        Vec_PtrForEachEntry( Gia_Obj_t *, vLeaves, pObj, i )
-            pObj->Value = Gia_ManAppendCi( pNew );
-    }
-    else
-    {
-        Gia_ManForEachPi( p, pObj, i )
-            pObj->Value = Gia_ManAppendCi( pNew );
-    }
-    // create LOs
-    Vec_PtrForEachEntryStart( Gia_Obj_t *, vRoots, pObj, i, nPos )
-        Gia_ObjRiToRo(p, pObj)->Value = Gia_ManAppendCi( pNew );
-    // create internal nodes
-    Vec_PtrForEachEntry( Gia_Obj_t *, vNodes, pObj, i )
-        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    // create COs
-    Vec_PtrForEachEntry( Gia_Obj_t *, vRoots, pObj, i )
-        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    // finalize
-    Gia_ManSetRegNum( pNew, Vec_PtrSize(vRoots)-nPos );
-    Vec_PtrFree( vLeaves );
-    Vec_PtrFree( vNodes );
-    Vec_PtrFree( vRoots );
-    return pNew;
-
-}
-Gia_Man_t * Gia_ManDupAndCones( Gia_Man_t * p, int * pAnds, int nAnds, int fTrimPis )
-{
-    Gia_Man_t * pNew;
-    Vec_Ptr_t * vLeaves, * vNodes, * vRoots;
-    Gia_Obj_t * pObj;
-    int i;
-
-    // collect initial POs
-    vLeaves = Vec_PtrAlloc( 100 );
-    vNodes = Vec_PtrAlloc( 100 );
-    vRoots = Vec_PtrAlloc( 100 );
-    for ( i = 0; i < nAnds; i++ )
-//        Vec_PtrPush( vRoots, Gia_ManPo(p, pPos[i]) );
-        Vec_PtrPush( vRoots, Gia_ManObj(p, pAnds[i]) );
-
-    // mark internal nodes
-    Gia_ManIncrementTravId( p );
-    Gia_ObjSetTravIdCurrent( p, Gia_ManConst0(p) );
-    Vec_PtrForEachEntry( Gia_Obj_t *, vRoots, pObj, i )
-        Gia_ManDupCones_rec( p, pObj, vLeaves, vNodes, vRoots );
-    Vec_PtrSort( vLeaves, (int (*)(void))Gia_ObjCompareByCioId );
-
-    // start the new manager
-//    Gia_ManFillValue( p );
-    pNew = Gia_ManStart( Vec_PtrSize(vLeaves) + Vec_PtrSize(vNodes) + Vec_PtrSize(vRoots) + 1);
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    // map the constant node
-    Gia_ManConst0(p)->Value = 0;
-    // create PIs
-    if ( fTrimPis )
-    {
-        Vec_PtrForEachEntry( Gia_Obj_t *, vLeaves, pObj, i )
-            pObj->Value = Gia_ManAppendCi( pNew );
-    }
-    else
-    {
-        Gia_ManForEachPi( p, pObj, i )
-            pObj->Value = Gia_ManAppendCi( pNew );
-    }
-    // create LOs
-//    Vec_PtrForEachEntryStart( Gia_Obj_t *, vRoots, pObj, i, nPos )
-//        Gia_ObjRiToRo(p, pObj)->Value = Gia_ManAppendCi( pNew );
-    // create internal nodes
-    Vec_PtrForEachEntry( Gia_Obj_t *, vNodes, pObj, i )
-        if ( Gia_ObjIsMux(p, pObj) )
-            pObj->Value = Gia_ManAppendMux( pNew, Gia_ObjFanin2Copy(p, pObj), Gia_ObjFanin1Copy(pObj), Gia_ObjFanin0Copy(pObj) );
-        else if ( Gia_ObjIsXor(pObj) )
-            pObj->Value = Gia_ManAppendXor( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-        else 
-            pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    // create COs
-    Vec_PtrForEachEntry( Gia_Obj_t *, vRoots, pObj, i )
-//        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-        Gia_ManAppendCo( pNew, pObj->Value );
-    // finalize
-//    Gia_ManSetRegNum( pNew, Vec_PtrSize(vRoots)-nPos );
-    Gia_ManSetRegNum( pNew, 0 );
-    Vec_PtrFree( vLeaves );
-    Vec_PtrFree( vNodes );
-    Vec_PtrFree( vRoots );
-    return pNew;
-
-}
-void Gia_ManDupAndConesLimit_rec( Gia_Man_t * pNew, Gia_Man_t * p, int iObj, int Level )
-{
-    Gia_Obj_t * pObj = Gia_ManObj(p, iObj);
-    if ( ~pObj->Value )
-        return;
-    if ( !Gia_ObjIsAnd(pObj) || Gia_ObjLevel(p, pObj) < Level )
-    {
-        pObj->Value = Gia_ManAppendCi( pNew );
-        //printf( "PI %d for %d.\n", Abc_Lit2Var(pObj->Value), iObj );
-        return;
-    }
-    Gia_ManDupAndConesLimit_rec( pNew, p, Gia_ObjFaninId0(pObj, iObj), Level );
-    Gia_ManDupAndConesLimit_rec( pNew, p, Gia_ObjFaninId1(pObj, iObj), Level );
-    pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    //printf( "Obj %d for %d.\n", Abc_Lit2Var(pObj->Value), iObj );
-}
-Gia_Man_t * Gia_ManDupAndConesLimit( Gia_Man_t * p, int * pAnds, int nAnds, int Level )
-{
-    Gia_Man_t * pNew;
-    int i;
-    pNew = Gia_ManStart( 1000 );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManLevelNum( p );
-    Gia_ManFillValue( p );
-    Gia_ManConst0(p)->Value = 0;
-    for ( i = 0; i < nAnds; i++ )
-        Gia_ManDupAndConesLimit_rec( pNew, p, pAnds[i], Level );
-    for ( i = 0; i < nAnds; i++ )
-        Gia_ManAppendCo( pNew, Gia_ManObj(p, pAnds[i])->Value );
-    return pNew;
-}
-
-void Gia_ManDupAndConesLimit2_rec( Gia_Man_t * pNew, Gia_Man_t * p, int iObj, int Level )
-{
-    Gia_Obj_t * pObj = Gia_ManObj(p, iObj);
-    if ( ~pObj->Value )
-        return;
-    if ( !Gia_ObjIsAnd(pObj) || Level <= 0 )
-    {
-        pObj->Value = Gia_ManAppendCi( pNew );
-        //printf( "PI %d for %d.\n", Abc_Lit2Var(pObj->Value), iObj );
-        return;
-    }
-    Gia_ManDupAndConesLimit2_rec( pNew, p, Gia_ObjFaninId0(pObj, iObj), Level-1 );
-    Gia_ManDupAndConesLimit2_rec( pNew, p, Gia_ObjFaninId1(pObj, iObj), Level-1 );
-    pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    //printf( "Obj %d for %d.\n", Abc_Lit2Var(pObj->Value), iObj );
-}
-Gia_Man_t * Gia_ManDupAndConesLimit2( Gia_Man_t * p, int * pAnds, int nAnds, int Level )
-{
-    Gia_Man_t * pNew;
-    int i;
-    pNew = Gia_ManStart( 1000 );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManFillValue( p );
-    Gia_ManConst0(p)->Value = 0;
-    for ( i = 0; i < nAnds; i++ )
-        Gia_ManDupAndConesLimit2_rec( pNew, p, pAnds[i], Level );
-    for ( i = 0; i < nAnds; i++ )
-        Gia_ManAppendCo( pNew, Gia_ManObj(p, pAnds[i])->Value );
-    return pNew;
-
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Generates AIG representing 1-hot condition for N inputs.]
-
-  Description [The condition is true of all POs are 0.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManOneHot( int nSkips, int nVars )
-{
-    Gia_Man_t * p;
-    int i, b, Shift, iGiaLit, nLogVars = Abc_Base2Log( nVars );
-    int * pTemp = ABC_CALLOC( int, (1 << nLogVars) );
-    p = Gia_ManStart( nSkips + 4 * nVars + 1 );
-    p->pName = Abc_UtilStrsav( "onehot" );
-    for ( i = 0; i < nSkips; i++ )
-        Gia_ManAppendCi( p );
-    for ( i = 0; i < nVars; i++ )
-        pTemp[i] = Gia_ManAppendCi( p );
-    Gia_ManHashStart( p );
-    for ( b = 0; b < nLogVars; b++ )
-        for ( i = 0, Shift = (1<<b); i < (1 << nLogVars); i += 2*Shift )
-        {
-            iGiaLit = Gia_ManHashAnd( p, pTemp[i], pTemp[i + Shift] );
-            if ( iGiaLit )
-                Gia_ManAppendCo( p, iGiaLit );
-            pTemp[i] = Gia_ManHashOr( p, pTemp[i], pTemp[i + Shift] );
-        }
-    Gia_ManHashStop( p );
-    Gia_ManAppendCo( p, Abc_LitNot(pTemp[0]) );
-    ABC_FREE( pTemp );
-    assert( Gia_ManObjNum(p) <= nSkips + 4 * nVars + 1 );
-    return p;
-}
-Gia_Man_t * Gia_ManDupOneHot( Gia_Man_t * p )
-{
-    Gia_Man_t * pOneHot, * pNew = Gia_ManDup( p );
-    if ( Gia_ManRegNum(pNew) == 0 )
-    {
-        Abc_Print( 0, "Appending 1-hotness constraints to the PIs.\n" );
-        pOneHot = Gia_ManOneHot( 0, Gia_ManCiNum(pNew) );
-    }
-    else
-        pOneHot = Gia_ManOneHot( Gia_ManPiNum(pNew), Gia_ManRegNum(pNew) );
-    Gia_ManDupAppendShare( pNew, pOneHot );
-    pNew->nConstrs += Gia_ManPoNum(pOneHot);
-    Gia_ManStop( pOneHot );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates the AIG with nodes ordered by level.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupLevelized( Gia_Man_t * p )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i, nLevels = Gia_ManLevelNum( p );
-    int * pCounts = ABC_CALLOC( int, nLevels + 1 );
-    int * pNodes = ABC_ALLOC( int, Gia_ManAndNum(p) );
-    Gia_ManForEachAnd( p, pObj, i )
-        pCounts[Gia_ObjLevel(p, pObj)]++;
-    for ( i = 1; i <= nLevels; i++ )
-        pCounts[i] += pCounts[i-1];
-    Gia_ManForEachAnd( p, pObj, i )
-        pNodes[pCounts[Gia_ObjLevel(p, pObj)-1]++] = i;
-    // duplicate
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachCi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi( pNew );
-    for ( i = 0; i < Gia_ManAndNum(p) && (pObj = Gia_ManObj(p, pNodes[i])); i++ )
-        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    Gia_ManForEachCo( p, pObj, i )
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    ABC_FREE( pCounts );
-    ABC_FREE( pNodes );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupFromVecs( Gia_Man_t * p, Vec_Int_t * vCis, Vec_Int_t * vAnds, Vec_Int_t * vCos, int nRegs )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i;
-    // start the new manager
-    pNew = Gia_ManStart( 5000 );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    // create constant
-    Gia_ManConst0(p)->Value = 0;
-    // create PIs
-    Gia_ManForEachObjVec( vCis, p, pObj, i )
-        pObj->Value = Gia_ManAppendCi( pNew );
-    // create internal nodes
-    Gia_ManForEachObjVec( vAnds, p, pObj, i )
-        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    // create ROs
-    Gia_ManForEachObjVec( vCos, p, pObj, i )
-        pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManSetRegNum( pNew, nRegs );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupSliced( Gia_Man_t * p, int nSuppMax )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i;
-    // start the new manager
-    pNew = Gia_ManStart( 5000 );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    // create constant and PIs
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachCi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi( pNew );
-    // create internal nodes
-    Gia_ManCleanMark01(p);
-    Gia_ManForEachAnd( p, pObj, i )
-        if ( Gia_ManSuppSize(p, &i, 1) <= nSuppMax )
-        {
-            pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-            pObj->fMark0 = 1;
-        }
-        else 
-        {
-            Gia_ObjFanin0(pObj)->fMark1 = 1;
-            Gia_ObjFanin1(pObj)->fMark1 = 1;
-        }
-    Gia_ManForEachCo( p, pObj, i )
-        Gia_ObjFanin0(pObj)->fMark1 = 1;
-    // add POs for the nodes pointed to
-    Gia_ManForEachAnd( p, pObj, i )
-        if ( pObj->fMark0 && pObj->fMark1 )
-            Gia_ManAppendCo( pNew, pObj->Value );
-    // cleanup and leave
-    Gia_ManCleanMark01(p);
-    return pNew;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Extract constraints.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Gia_ManDupWithConstrCollectAnd_rec( Gia_Man_t * p, Gia_Obj_t * pObj, Vec_Int_t * vSuper, int fFirst )
-{
-    if ( (Gia_IsComplement(pObj) || !Gia_ObjIsAnd(pObj)) && !fFirst )
-    {
-        Vec_IntPushUnique( vSuper, Gia_ObjToLit(p, pObj) );
-        return;
-    }
-    Gia_ManDupWithConstrCollectAnd_rec( p, Gia_ObjChild0(pObj), vSuper, 0 );
-    Gia_ManDupWithConstrCollectAnd_rec( p, Gia_ObjChild1(pObj), vSuper, 0 );
-}
-Gia_Man_t * Gia_ManDupWithConstr( Gia_Man_t * p )
-{
-    Vec_Int_t * vSuper;
-    Gia_Man_t * pNew, * pTemp;
-    Gia_Obj_t * pObj;
-    int i, iDriver, iLit, iLitBest = -1, LevelBest = -1;
-    assert( Gia_ManPoNum(p) == 1 );
-    assert( Gia_ManRegNum(p) == 0 );
-    pObj = Gia_ManPo( p, 0 );
-    if ( Gia_ObjFaninC0(pObj) )
-    {
-        printf( "The miter's output is not AND-decomposable.\n" );
-        return NULL;
-    }
-    if ( Gia_ObjFaninId0p(p, pObj) == 0 )
-    {
-        printf( "The miter's output is a constant.\n" );
-        return NULL;
-    }
-    vSuper = Vec_IntAlloc( 100 );
-    Gia_ManDupWithConstrCollectAnd_rec( p, Gia_ObjChild0(pObj), vSuper, 1 );
-    assert( Vec_IntSize(vSuper) > 1 );
-    // find the highest level
-    Gia_ManLevelNum( p );
-    Vec_IntForEachEntry( vSuper, iLit, i )
-        if ( LevelBest < Gia_ObjLevelId(p, Abc_Lit2Var(iLit)) )
-            LevelBest = Gia_ObjLevelId(p, Abc_Lit2Var(iLit)), iLitBest = iLit;
-    assert( iLitBest != -1 );
-    // create new manager
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManHashAlloc( pNew );
-    Gia_ManForEachObj1( p, pObj, i )
-    {
-        if ( Gia_ObjIsAnd(pObj) )
-            pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-        else if ( Gia_ObjIsCi(pObj) )
-            pObj->Value = Gia_ManAppendCi( pNew );
-    }
-    // create AND of nodes
-    iDriver = -1;
-    Vec_IntForEachEntry( vSuper, iLit, i )
-    {
-        if ( iLit == iLitBest )
-            continue;
-        if ( iDriver == -1 )
-            iDriver = Gia_ObjLitCopy(p, iLit);
-        else
-            iDriver = Gia_ManHashAnd( pNew, iDriver, Gia_ObjLitCopy(p, iLit) );
-    }
-    // create the main PO
-    Gia_ManAppendCo( pNew, Gia_ObjLitCopy(p, iLitBest) );
-    // create the constraint PO
-    Gia_ManAppendCo( pNew, Abc_LitNot(iDriver) );
-    pNew->nConstrs = 1;
-    // rehash
-    pNew = Gia_ManCleanup( pTemp = pNew );
-    Gia_ManStop( pTemp );
-    Vec_IntFree( vSuper );
-    return pNew;
-
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Compares two objects by their distance.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Gia_ManSortByValue( Gia_Obj_t ** pp1, Gia_Obj_t ** pp2 )
-{
-    int Diff = Gia_Regular(*pp1)->Value - Gia_Regular(*pp2)->Value;
-    if ( Diff < 0 )
-        return -1;
-    if ( Diff > 0 ) 
-        return 1;
-    return 0; 
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Decomposes the miter outputs.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupOuts( Gia_Man_t * p )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    int i;
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachCi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi(pNew);
-    Gia_ManForEachAnd( p, pObj, i )
-        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    Gia_ManForEachPo( p, pObj, i )
-        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManForEachAnd( p, pObj, i )
-        Gia_ManAppendCo( pNew, pObj->Value );
-    Gia_ManForEachRi( p, pObj, i )
-        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    assert( Gia_ManIsNormalized(pNew) );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Computes supports for each node.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Wec_t * Gia_ManCreateNodeSupps( Gia_Man_t * p, Vec_Int_t * vNodes, int fVerbose )
-{
-    abctime clk = Abc_Clock();
-    Gia_Obj_t * pObj; int i, Id;
-    Vec_Wec_t * vSuppsNo = Vec_WecStart( Vec_IntSize(vNodes) );
-    Vec_Wec_t * vSupps = Vec_WecStart( Gia_ManObjNum(p) );
-    Gia_ManForEachCiId( p, Id, i )
-        Vec_IntPush( Vec_WecEntry(vSupps, Id), i );
-    Gia_ManForEachAnd( p, pObj, Id )
-        Vec_IntTwoMerge2( Vec_WecEntry(vSupps, Gia_ObjFaninId0(pObj, Id)), 
-                          Vec_WecEntry(vSupps, Gia_ObjFaninId1(pObj, Id)), 
-                          Vec_WecEntry(vSupps, Id) ); 
-    Gia_ManForEachObjVec( vNodes, p, pObj, i )
-        Vec_IntAppend( Vec_WecEntry(vSuppsNo, i), Vec_WecEntry(vSupps, Gia_ObjId(p, pObj)) );
-    Vec_WecFree( vSupps );
-    if ( fVerbose )
-        Abc_PrintTime( 1, "Support computation", Abc_Clock() - clk );
-    return vSuppsNo;
-}
-
-Vec_Wec_t * Gia_ManCreateCoSupps( Gia_Man_t * p, int fVerbose )
-{
-    abctime clk = Abc_Clock();
-    Gia_Obj_t * pObj; int i, Id;
-    Vec_Wec_t * vSuppsCo = Vec_WecStart( Gia_ManCoNum(p) );
-    Vec_Wec_t * vSupps = Vec_WecStart( Gia_ManObjNum(p) );
-    Gia_ManForEachCiId( p, Id, i )
-        Vec_IntPush( Vec_WecEntry(vSupps, Id), i );
-    Gia_ManForEachAnd( p, pObj, Id )
-        Vec_IntTwoMerge2( Vec_WecEntry(vSupps, Gia_ObjFaninId0(pObj, Id)), 
-                          Vec_WecEntry(vSupps, Gia_ObjFaninId1(pObj, Id)), 
-                          Vec_WecEntry(vSupps, Id) ); 
-    Gia_ManForEachCo( p, pObj, i )
-        Vec_IntAppend( Vec_WecEntry(vSuppsCo, i), Vec_WecEntry(vSupps, Gia_ObjFaninId0p(p, pObj)) );
-    Vec_WecFree( vSupps );
-    if ( fVerbose )
-        Abc_PrintTime( 1, "Support computation", Abc_Clock() - clk );
-    return vSuppsCo;
-}
-int Gia_ManCoSuppSizeMax( Gia_Man_t * p, Vec_Wec_t * vSupps )
-{
-    Gia_Obj_t * pObj; 
-    Vec_Int_t * vSuppOne;
-    int i, nSuppMax = 1;
-    Gia_ManForEachCo( p, pObj, i )
-    {
-        vSuppOne = Vec_WecEntry( vSupps, i );
-        nSuppMax = Abc_MaxInt( nSuppMax, Vec_IntSize(vSuppOne) );
-    }
-    return nSuppMax;
-}
-int Gia_ManCoLargestSupp( Gia_Man_t * p, Vec_Wec_t * vSupps )
-{
-    Gia_Obj_t * pObj; 
-    Vec_Int_t * vSuppOne;
-    int i, iCoMax = -1, nSuppMax = -1;
-    Gia_ManForEachCo( p, pObj, i )
-    {
-        vSuppOne = Vec_WecEntry( vSupps, i );
-        if ( nSuppMax < Vec_IntSize(vSuppOne) )
-        {
-            nSuppMax = Vec_IntSize(vSuppOne);
-            iCoMax = i;
-        }
-    }
-    return iCoMax;
-}
-Vec_Int_t * Gia_ManSortCoBySuppSize( Gia_Man_t * p, Vec_Wec_t * vSupps )
-{
-    Vec_Int_t * vOrder = Vec_IntAlloc( Gia_ManCoNum(p) );
-    Vec_Wrd_t * vSortData = Vec_WrdAlloc( Gia_ManCoNum(p) );
-    Vec_Int_t * vSuppOne; word Entry; int i;
-    Vec_WecForEachLevel( vSupps, vSuppOne, i )
-        Vec_WrdPush( vSortData, ((word)i << 32) | Vec_IntSize(vSuppOne) );
-    Abc_QuickSort3( Vec_WrdArray(vSortData), Vec_WrdSize(vSortData), 1 );
-    Vec_WrdForEachEntry( vSortData, Entry, i )
-        Vec_IntPush( vOrder, (int)(Entry >> 32) );
-    Vec_WrdFree( vSortData );
-    return vOrder;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Remaps each CO cone to depend on the first CI variables.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Gia_ManDupHashDfs_rec( Gia_Man_t * pNew, Gia_Man_t * p, Gia_Obj_t * pObj )
-{
-    if ( ~pObj->Value )
-        return pObj->Value;
-    assert( Gia_ObjIsAnd(pObj) );
-    Gia_ManDupHashDfs_rec( pNew, p, Gia_ObjFanin0(pObj) );
-    Gia_ManDupHashDfs_rec( pNew, p, Gia_ObjFanin1(pObj) );
-    return pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-} 
-void Gia_ManDupCleanDfs_rec( Gia_Obj_t * pObj )
-{
-    if ( !~pObj->Value )
-        return;
-    pObj->Value = ~0;
-    if ( Gia_ObjIsCi(pObj) )
-        return;
-    assert( Gia_ObjIsAnd(pObj) );
-    Gia_ManDupCleanDfs_rec( Gia_ObjFanin0(pObj) );
-    Gia_ManDupCleanDfs_rec( Gia_ObjFanin1(pObj) );
-} 
-Gia_Man_t * Gia_ManDupStrashReduce( Gia_Man_t * p, Vec_Wec_t * vSupps, Vec_Int_t ** pvCoMap )
-{
-    Gia_Obj_t * pObj;
-    Gia_Man_t * pNew, * pTemp;
-    Vec_Int_t * vSuppOne, * vCoMapLit;
-    int i, k, iCi, iLit, nSuppMax;
-    assert( Gia_ManRegNum(p) == 0 );
-    Gia_ManFillValue( p );
-    vCoMapLit = Vec_IntAlloc( Gia_ManCoNum(p) );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    nSuppMax = Gia_ManCoSuppSizeMax( p, vSupps );
-    for ( i = 0; i < nSuppMax; i++ )
-        Gia_ManAppendCi(pNew);
-    Gia_ManHashAlloc( pNew );
-    Gia_ManForEachCo( p, pObj, i )
-    {
-        vSuppOne = Vec_WecEntry( vSupps, i );
-        if ( Vec_IntSize(vSuppOne) == 0 )
-            Vec_IntPush( vCoMapLit, Abc_Var2Lit(0, Gia_ObjFaninC0(pObj)) );
-        else if ( Vec_IntSize(vSuppOne) == 1 )
-            Vec_IntPush( vCoMapLit, Abc_Var2Lit(1, Gia_ObjFaninC0(pObj)) );
-        else
-        {
-            Vec_IntForEachEntry( vSuppOne, iCi, k )
-                Gia_ManCi(p, iCi)->Value = Gia_Obj2Lit(pNew, Gia_ManCi(pNew, k) );
-            Gia_ManDupHashDfs_rec( pNew, p, Gia_ObjFanin0(pObj) );
-            assert( Gia_ObjFanin0Copy(pObj) < 2 * Gia_ManObjNum(pNew) );
-            Vec_IntPush( vCoMapLit, Gia_ObjFanin0Copy(pObj) );
-            Gia_ManDupCleanDfs_rec( Gia_ObjFanin0(pObj) );
-        }
-    }
-    Gia_ManHashStop( pNew );
-    assert( Vec_IntSize(vCoMapLit) == Gia_ManCoNum(p) );
-    if ( pvCoMap == NULL ) // do not remap
-    {
-        Vec_IntForEachEntry( vCoMapLit, iLit, i )
-            Gia_ManAppendCo( pNew, iLit );
-    }
-    else // remap
-    {
-        Vec_Int_t * vCoMapRes = Vec_IntAlloc( Gia_ManCoNum(p) );      // map old CO into new CO 
-        Vec_Int_t * vMap = Vec_IntStartFull( 2*Gia_ManObjNum(pNew) ); // map new lit into new CO
-        Vec_IntForEachEntry( vCoMapLit, iLit, i )
-        {
-            if ( Vec_IntEntry(vMap, iLit) == -1 )
-            {
-                Vec_IntWriteEntry( vMap, iLit, Gia_ManCoNum(pNew) );
-                Gia_ManAppendCo( pNew, iLit );
-            }
-            Vec_IntPush( vCoMapRes, Vec_IntEntry(vMap, iLit) );
-        }
-        Vec_IntFree( vMap );
-        *pvCoMap = vCoMapRes;
-    }
-    Vec_IntFree( vCoMapLit );
-    pNew = Gia_ManCleanup( pTemp = pNew );
-    Gia_ManStop( pTemp );
-    return pNew;
-}
-Gia_Man_t * Gia_ManIsoStrashReduce2( Gia_Man_t * p, Vec_Ptr_t ** pvPosEquivs, int fVerbose )
-{
-    Vec_Int_t * vCoMap;
-    Vec_Wec_t * vSupps = Gia_ManCreateCoSupps( p, fVerbose );
-    Gia_Man_t * pNew = Gia_ManDupStrashReduce( p, vSupps, &vCoMap );
-    Vec_IntFree( vCoMap );
-    Vec_WecFree( vSupps );
-    *pvPosEquivs = NULL;
-    return pNew;
-}
-
-int Gia_ManIsoStrashReduceOne( Gia_Man_t * pNew, Gia_Man_t * p, Gia_Obj_t * pObj, Vec_Int_t * vSupp )
-{
-    int k, iCi, iLit;
-    assert( Gia_ObjIsCo(pObj) );
-    if ( Vec_IntSize(vSupp) == 0 )
-        return Abc_Var2Lit(0, Gia_ObjFaninC0(pObj));
-    if ( Vec_IntSize(vSupp) == 1 )
-        return Abc_Var2Lit(1, Gia_ObjFaninC0(pObj));
-    Vec_IntForEachEntry( vSupp, iCi, k )
-        Gia_ManCi(p, iCi)->Value = Gia_Obj2Lit(pNew, Gia_ManCi(pNew, k) );
-    Gia_ManDupHashDfs_rec( pNew, p, Gia_ObjFanin0(pObj) );
-    iLit = Gia_ObjFanin0Copy(pObj);
-    Gia_ManDupCleanDfs_rec( Gia_ObjFanin0(pObj) );
-    return iLit;
-}
-Vec_Wec_t * Gia_ManIsoStrashReduceInt( Gia_Man_t * p, Vec_Wec_t * vSupps, int fVerbose )
-{
-    Gia_Man_t * pNew;
-    Gia_Obj_t * pObj;
-    Vec_Wec_t * vPosEquivs = Vec_WecAlloc( 100 );
-    Vec_Int_t * vSuppOne, * vMap = Vec_IntAlloc( 10000 );
-    int i, iLit, nSuppMax = Gia_ManCoSuppSizeMax( p, vSupps );
-    // count how many times each support size appears
-    Vec_Int_t * vSizeCount = Vec_IntStart( nSuppMax + 1 );
-    Vec_WecForEachLevel( vSupps, vSuppOne, i )
-        Vec_IntAddToEntry( vSizeCount, Vec_IntSize(vSuppOne), 1 );
-    // create array of unique outputs
-    Gia_ManFillValue( p );
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    Gia_ManConst0(p)->Value = 0;
-    for ( i = 0; i < nSuppMax; i++ )
-        Gia_ManAppendCi(pNew);
-    Gia_ManHashAlloc( pNew );
-    Gia_ManForEachCo( p, pObj, i )
-    {
-        vSuppOne = Vec_WecEntry( vSupps, i );
-        if ( Vec_IntEntry(vSizeCount, Vec_IntSize(vSuppOne)) == 1 )
-        {
-            Vec_IntPush( Vec_WecPushLevel(vPosEquivs), i );
-            continue;
-        }
-        iLit = Gia_ManIsoStrashReduceOne( pNew, p, pObj, vSuppOne );
-        Vec_IntFillExtra( vMap, iLit + 1, -1 );
-        if ( Vec_IntEntry(vMap, iLit) == -1 )
-        {
-            Vec_IntWriteEntry( vMap, iLit, Vec_WecSize(vPosEquivs) );
-            Vec_IntPush( Vec_WecPushLevel(vPosEquivs), i );
-            continue;
-        }
-        Vec_IntPush( Vec_WecEntry(vPosEquivs, Vec_IntEntry(vMap, iLit)), i );
-    }
-    Gia_ManHashStop( pNew );
-    Gia_ManStop( pNew );
-    Vec_IntFree( vSizeCount );
-    Vec_IntFree( vMap );
-    return vPosEquivs;
-}
-Gia_Man_t * Gia_ManIsoStrashReduce( Gia_Man_t * p, Vec_Ptr_t ** pvPosEquivs, int fVerbose )
-{
-    Vec_Wec_t * vSupps = Gia_ManCreateCoSupps( p, fVerbose );
-    Vec_Wec_t * vPosEquivs = Gia_ManIsoStrashReduceInt( p, vSupps, fVerbose );
-    // find the first outputs and derive GIA
-    Vec_Int_t * vFirsts = Vec_WecCollectFirsts( vPosEquivs );
-    Gia_Man_t * pNew = Gia_ManDupCones( p, Vec_IntArray(vFirsts), Vec_IntSize(vFirsts), 0 );
-    Vec_IntFree( vFirsts );
-    Vec_WecFree( vSupps );
-    // report and return    
-    if ( fVerbose )
-    { 
-        printf( "Nontrivial classes:\n" );
-        Vec_WecPrint( vPosEquivs, 1 );
-    }
-    if ( pvPosEquivs )
-        *pvPosEquivs = Vec_WecConvertToVecPtr( vPosEquivs );
-    Vec_WecFree( vPosEquivs );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Decomposes the miter outputs.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Gia_Man_t * Gia_ManDupDemiter( Gia_Man_t * p, int fVerbose )
-{
-    Vec_Int_t * vSuper;
-    Vec_Ptr_t * vSuperPtr;
-    Gia_Man_t * pNew, * pTemp;
-    Gia_Obj_t * pObj, * pObjPo;
-    int i, iLit;
-    assert( Gia_ManPoNum(p) == 1 );
-    // decompose
-    pObjPo = Gia_ManPo( p, 0 );
-    vSuper = Vec_IntAlloc( 100 );
-    Gia_ManDupWithConstrCollectAnd_rec( p, Gia_ObjFanin0(pObjPo), vSuper, 1 );
-    assert( Vec_IntSize(vSuper) > 1 );
-    // report the result
-    printf( "The miter is %s-decomposable into %d parts.\n", Gia_ObjFaninC0(pObjPo) ? "OR":"AND", Vec_IntSize(vSuper) );
-    // create levels
-    Gia_ManLevelNum( p );
-    Vec_IntForEachEntry( vSuper, iLit, i )
-        Gia_ManObj(p, Abc_Lit2Var(iLit))->Value = Gia_ObjLevelId(p, Abc_Lit2Var(iLit));
-    // create pointer array
-    vSuperPtr = Vec_PtrAlloc( Vec_IntSize(vSuper) );
-    Vec_IntForEachEntry( vSuper, iLit, i )
-        Vec_PtrPush( vSuperPtr, Gia_Lit2Obj(p, iLit) );
-    Vec_PtrSort( vSuperPtr, (int (*)(void))Gia_ManSortByValue );
-    // create new manager
-    pNew = Gia_ManStart( Gia_ManObjNum(p) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManHashAlloc( pNew );
-    Gia_ManForEachCi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi( pNew );
-    Gia_ManForEachAnd( p, pObj, i )
-        pObj->Value = Gia_ManHashAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    // create the outputs
-    Vec_PtrForEachEntry( Gia_Obj_t *, vSuperPtr, pObj, i )
-        Gia_ManAppendCo( pNew, Gia_ObjLitCopy(p, Gia_Obj2Lit(p, pObj)) ^ Gia_ObjFaninC0(pObjPo) );
-    Gia_ManForEachRi( p, pObj, i )
-        Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-    Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) );
-    // rehash
-    pNew = Gia_ManCleanup( pTemp = pNew );
-    Gia_ManStop( pTemp );
-    Vec_IntFree( vSuper );
-    Vec_PtrFree( vSuperPtr );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Gia_ManDupDemiterOrderXors2( Gia_Man_t * p, Vec_Int_t * vXors )
-{
-    int i, iObj, * pPerm;
-    Vec_Int_t * vSizes = Vec_IntAlloc( 100 );
-    Vec_IntForEachEntry( vXors, iObj, i )
-        Vec_IntPush( vSizes, Gia_ManSuppSize(p, &iObj, 1) );
-    pPerm = Abc_MergeSortCost( Vec_IntArray(vSizes), Vec_IntSize(vSizes) );
-    Vec_IntClear( vSizes );
-    for ( i = 0; i < Vec_IntSize(vXors); i++ )
-        Vec_IntPush( vSizes, Vec_IntEntry(vXors, pPerm[i]) );
-    ABC_FREE( pPerm );
-    Vec_IntClear( vXors );
-    Vec_IntAppend( vXors, vSizes );
-    Vec_IntFree( vSizes );
-}
-int Gia_ManDupDemiterFindMin( Vec_Wec_t * vSupps, Vec_Int_t * vTakenIns, Vec_Int_t * vTakenOuts )
-{
-    Vec_Int_t * vLevel;
-    int i, k, iObj, iObjBest = -1;
-    int Count, CountBest = ABC_INFINITY;
-    Vec_WecForEachLevel( vSupps, vLevel, i )
-    {
-        if ( Vec_IntEntry(vTakenOuts, i) )
-            continue;
-        Count = 0;
-        Vec_IntForEachEntry( vLevel, iObj, k )
-            Count += !Vec_IntEntry(vTakenIns, iObj);
-        if ( CountBest > Count )
-        {
-            CountBest = Count;
-            iObjBest = i;
-        }
-    }
-    return iObjBest;
-}
-void Gia_ManDupDemiterOrderXors( Gia_Man_t * p, Vec_Int_t * vXors )
-{
-    extern Vec_Wec_t * Gia_ManCreateNodeSupps( Gia_Man_t * p, Vec_Int_t * vNodes, int fVerbose );
-    Vec_Wec_t * vSupps = Gia_ManCreateNodeSupps( p, vXors, 0 );
-    Vec_Int_t * vTakenIns = Vec_IntStart( Gia_ManCiNum(p) );
-    Vec_Int_t * vTakenOuts = Vec_IntStart( Vec_IntSize(vXors) );
-    Vec_Int_t * vOrder = Vec_IntAlloc( Vec_IntSize(vXors) );
-    int i, k, iObj;
-    // add outputs in the order of increasing supports
-    for ( i = 0; i < Vec_IntSize(vXors); i++ )
-    {
-        int Index = Gia_ManDupDemiterFindMin( vSupps, vTakenIns, vTakenOuts );
-        assert( Index >= 0 && Index < Vec_IntSize(vXors) );
-        Vec_IntPush( vOrder, Vec_IntEntry(vXors, Index) );
-        assert( !Vec_IntEntry( vTakenOuts, Index ) );
-        Vec_IntWriteEntry( vTakenOuts, Index, 1 );
-        Vec_IntForEachEntry( Vec_WecEntry(vSupps, Index), iObj, k )
-            Vec_IntWriteEntry( vTakenIns, iObj, 1 );
-    }
-    Vec_WecFree( vSupps );
-    Vec_IntFree( vTakenIns );
-    Vec_IntFree( vTakenOuts );
-    // reload
-    Vec_IntClear( vXors );
-    Vec_IntAppend( vXors, vOrder );
-    Vec_IntFree( vOrder );
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Gia_ManSetMark0Dfs_rec( Gia_Man_t * p, int iObj )
-{
-    Gia_Obj_t * pObj;
-    pObj = Gia_ManObj( p, iObj );
-    if ( pObj->fMark0 )
-        return;
-    pObj->fMark0 = 1;
-    if ( !Gia_ObjIsAnd(pObj) )
-        return;
-    Gia_ManSetMark0Dfs_rec( p, Gia_ObjFaninId0(pObj, iObj) );
-    Gia_ManSetMark0Dfs_rec( p, Gia_ObjFaninId1(pObj, iObj) );
-}
-void Gia_ManSetMark1Dfs_rec( Gia_Man_t * p, int iObj )
-{
-    Gia_Obj_t * pObj;
-    pObj = Gia_ManObj( p, iObj );
-    if ( pObj->fMark1 )
-        return;
-    pObj->fMark1 = 1;
-    if ( !Gia_ObjIsAnd(pObj) )
-        return;
-    Gia_ManSetMark1Dfs_rec( p, Gia_ObjFaninId0(pObj, iObj) );
-    Gia_ManSetMark1Dfs_rec( p, Gia_ObjFaninId1(pObj, iObj) );
-}
-
-int Gia_ManCountMark0Dfs_rec( Gia_Man_t * p, int iObj )
-{
-    Gia_Obj_t * pObj;
-    if ( Gia_ObjIsTravIdCurrentId(p, iObj) )
-        return 0;
-    Gia_ObjSetTravIdCurrentId(p, iObj);
-    pObj = Gia_ManObj( p, iObj );
-    if ( !Gia_ObjIsAnd(pObj) )
-        return pObj->fMark0;
-    return Gia_ManCountMark0Dfs_rec( p, Gia_ObjFaninId0(pObj, iObj) ) + 
-           Gia_ManCountMark0Dfs_rec( p, Gia_ObjFaninId1(pObj, iObj) ) + pObj->fMark0;
-}
-int Gia_ManCountMark0Dfs( Gia_Man_t * p, int iObj )
-{
-    Gia_ManIncrementTravId( p );
-    return Gia_ManCountMark0Dfs_rec( p, iObj );
-}
-int Gia_ManCountMark1Dfs_rec( Gia_Man_t * p, int iObj )
-{
-    Gia_Obj_t * pObj;
-    if ( Gia_ObjIsTravIdCurrentId(p, iObj) )
-        return 0;
-    Gia_ObjSetTravIdCurrentId(p, iObj);
-    pObj = Gia_ManObj( p, iObj );
-    if ( !Gia_ObjIsAnd(pObj) )
-        return pObj->fMark1;
-    return Gia_ManCountMark1Dfs_rec( p, Gia_ObjFaninId0(pObj, iObj) ) + 
-           Gia_ManCountMark1Dfs_rec( p, Gia_ObjFaninId1(pObj, iObj) ) + pObj->fMark1;
-}
-int Gia_ManCountMark1Dfs( Gia_Man_t * p, int iObj )
-{
-    Gia_ManIncrementTravId( p );
-    return Gia_ManCountMark1Dfs_rec( p, iObj );
-}
-
-int Gia_ManDecideWhereToAdd( Gia_Man_t * p, Vec_Int_t * vPart[2], Gia_Obj_t * pFan[2] )
-{
-    int Count0 = 1, Count1 = 0;
-    assert( Vec_IntSize(vPart[0]) == Vec_IntSize(vPart[1]) );
-    if ( Vec_IntSize(vPart[0]) > 0 )
-    {
-        Count0 = Gia_ManCountMark0Dfs(p, Gia_ObjId(p, pFan[0])) + Gia_ManCountMark1Dfs(p, Gia_ObjId(p, pFan[1]));
-        Count1 = Gia_ManCountMark0Dfs(p, Gia_ObjId(p, pFan[1])) + Gia_ManCountMark1Dfs(p, Gia_ObjId(p, pFan[0]));
-    }
-    return Count0 < Count1;
-}
-void Gia_ManCollectTopXors_rec( Gia_Man_t * p, Gia_Obj_t * pObj, Vec_Int_t * vXors )
-{
-    Gia_Obj_t * pFan0, * pFan1;
-    int iObj = Gia_ObjId( p, pObj );
-    if ( Gia_ObjRecognizeExor(pObj, &pFan0, &pFan1) || !Gia_ObjIsAnd(pObj) )
-    {
-        Vec_IntPushUnique( vXors, Gia_ObjId(p, pObj) );
-        return;
-    }
-    if ( Gia_ObjFaninC0(pObj) )
-        Vec_IntPushUnique( vXors, Gia_ObjFaninId0(pObj, iObj) );
-    else
-        Gia_ManCollectTopXors_rec( p, Gia_ObjFanin0(pObj), vXors );
-    if ( Gia_ObjFaninC1(pObj) )
-        Vec_IntPushUnique( vXors, Gia_ObjFaninId1(pObj, iObj) );
-    else
-        Gia_ManCollectTopXors_rec( p, Gia_ObjFanin1(pObj), vXors );
-}
-Vec_Int_t * Gia_ManCollectTopXors( Gia_Man_t * p )
-{
-    int i, iObj, iObj2, fFlip, Count1 = 0;
-    Vec_Int_t * vXors, * vPart[2], * vOrder; 
-    Gia_Obj_t * pFan[2], * pObj = Gia_ManCo(p, 0);
-    vXors = Vec_IntAlloc( 100 );
-    if ( Gia_ManCoNum(p) == 1 )
-    {
-        if ( Gia_ObjFaninC0(pObj) )
-            Gia_ManCollectTopXors_rec( p, Gia_ObjFanin0(pObj), vXors );
-        else
-            Vec_IntPush( vXors, Gia_ObjId(p, Gia_ObjFanin0(pObj)) );
-    }
-    else
-    {
-        Gia_ManForEachCo( p, pObj, i )
-            if ( Gia_ObjFaninId0p(p, pObj) > 0 )
-                Vec_IntPush( vXors, Gia_ObjFaninId0p(p, pObj) );
-    }
-    // order by support size
-    Gia_ManDupDemiterOrderXors( p, vXors );
-    //Vec_IntPrint( vXors );
-    Vec_IntReverseOrder( vXors ); // from MSB to LSB
-    // divide into groups
-    Gia_ManCleanMark01(p);
-    vPart[0] = Vec_IntAlloc( 100 );
-    vPart[1] = Vec_IntAlloc( 100 );
-    Gia_ManForEachObjVec( vXors, p, pObj, i )
-    {
-        int fCompl = 0;
-        if ( !Gia_ObjRecognizeExor(pObj, &pFan[0], &pFan[1]) )
-            pFan[0] = pObj, pFan[1] = Gia_ManConst0(p), Count1++;
-        else
-        {
-            fCompl ^= Gia_IsComplement(pFan[0]);
-            fCompl ^= Gia_IsComplement(pFan[1]);
-            pFan[0] = Gia_Regular(pFan[0]);
-            pFan[1] = Gia_Regular(pFan[1]);
-        }
-        fFlip = Gia_ManDecideWhereToAdd( p, vPart, pFan );
-        Vec_IntPush( vPart[0], Gia_ObjId(p, pFan[fFlip]) );
-        Vec_IntPush( vPart[1], Gia_ObjId(p, pFan[!fFlip]) );
-        Gia_ManSetMark0Dfs_rec( p, Gia_ObjId(p, pFan[fFlip]) );
-        Gia_ManSetMark1Dfs_rec( p, Gia_ObjId(p, pFan[!fFlip]) );
-    }
-    //printf( "Detected %d single-output XOR miters and %d other miters.\n", Vec_IntSize(vXors) - Count1, Count1 );
-    Vec_IntFree( vXors );
-    Gia_ManCleanMark01(p);
-    // create new order
-    vOrder = Vec_IntAlloc( 100 );
-    Vec_IntForEachEntryTwo( vPart[0], vPart[1], iObj, iObj2, i )
-        Vec_IntPushTwo( vOrder, iObj, iObj2 );
-    Vec_IntFree( vPart[0] );
-    Vec_IntFree( vPart[1] );
-    Vec_IntReverseOrder( vOrder ); // from LSB to MSB
-    //Vec_IntPrint( vOrder );
-    return vOrder;
-}
-Gia_Man_t * Gia_ManDemiterToDual( Gia_Man_t * p )
-{
-    Gia_Man_t * pNew; Gia_Obj_t * pObj; int i;
-    Vec_Int_t * vNodes;
-    Vec_Int_t * vOrder = Gia_ManCollectTopXors( p );
-    if ( vOrder == NULL )
-    {
-        printf( "Cannot demiter because the top-most gate is an AND-gate.\n" );
-        return NULL;
-    }
-    assert( Vec_IntSize(vOrder) % 2 == 0 );
-    vNodes = Vec_IntAlloc( Gia_ManObjNum(p) );
-    Gia_ManIncrementTravId( p );
-    Gia_ManCollectAnds( p, Vec_IntArray(vOrder), Vec_IntSize(vOrder), vNodes, NULL );
-    pNew = Gia_ManStart( 1 + Gia_ManCiNum(p) + Vec_IntSize(vNodes) + Vec_IntSize(vOrder) );
-    pNew->pName = Abc_UtilStrsav( p->pName );
-    pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-    Gia_ManConst0(p)->Value = 0;
-    Gia_ManForEachCi( p, pObj, i )
-        pObj->Value = Gia_ManAppendCi( pNew );
-    Gia_ManForEachObjVec( vNodes, p, pObj, i )
-        pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-    pObj = Gia_ManCo(p, 0);
-    if ( Gia_ObjFanin0(pObj) == Gia_ManConst0(p) )
-    {
-        Gia_ManAppendCo( pNew, 0 );
-        Gia_ManAppendCo( pNew, Gia_ObjFaninC0(pObj) );
-    }
-    else
-    {
-        Gia_ManSetPhase( p );
-        Gia_ManForEachObjVec( vOrder, p, pObj, i )
-            Gia_ManAppendCo( pNew, Abc_LitNotCond(pObj->Value, pObj->fPhase) );
-    }
-    Vec_IntFree( vNodes );
-    Vec_IntFree( vOrder );
-    return pNew;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Collect nodes reachable from odd/even outputs.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Gia_ManCollectDfs_rec( Gia_Man_t * p, int iObj, Vec_Int_t * vNodes )
-{
-    Gia_Obj_t * pObj;
-    if ( Gia_ObjIsTravIdCurrentId(p, iObj) )
-        return;
-    Gia_ObjSetTravIdCurrentId(p, iObj);
-    pObj = Gia_ManObj( p, iObj );
-    if ( !Gia_ObjIsAnd(pObj) )
-        return;
-    Gia_ManCollectDfs_rec( p, Gia_ObjFaninId0(pObj, iObj), vNodes );
-    Gia_ManCollectDfs_rec( p, Gia_ObjFaninId1(pObj, iObj), vNodes );
-    Vec_IntPush( vNodes, iObj );
-}
-Vec_Int_t * Gia_ManCollectReach( Gia_Man_t * p, int fOdd )
-{
-    int i, iDriver;
-    Vec_Int_t * vNodes = Vec_IntAlloc( Gia_ManObjNum(p) );
-    Gia_ManIncrementTravId( p );
-    Gia_ObjSetTravIdCurrent( p, Gia_ManConst0(p) );
-    Gia_ManForEachCoDriverId( p, iDriver, i )
-        if ( (i & 1) == fOdd )
-            Gia_ManCollectDfs_rec( p, iDriver, vNodes );
-    return vNodes;
-}
-int Gia_ManDemiterDual( Gia_Man_t * p, Gia_Man_t ** pp0, Gia_Man_t ** pp1 )
-{
-    Gia_Obj_t * pObj;
-    int i, fOdd;
-    assert( Gia_ManRegNum(p) == 0 );
-    assert( Gia_ManCoNum(p) % 2 == 0 );
-    *pp0 = *pp1 = NULL;
-    for ( fOdd = 0; fOdd < 2; fOdd++ )
-    {
-        Vec_Int_t * vNodes = Gia_ManCollectReach( p, fOdd );
-        Gia_Man_t * pNew = Gia_ManStart( 1 + Gia_ManCiNum(p) + Vec_IntSize(vNodes) + Gia_ManCoNum(p)/2 );
-        pNew->pName = Abc_UtilStrsav( p->pName );
-        pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-        Gia_ManConst0(p)->Value = 0;
-        Gia_ManForEachPi( p, pObj, i )
-            pObj->Value = Gia_ManAppendCi( pNew );
-        Gia_ManForEachObjVec( vNodes, p, pObj, i )
-            pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-        Gia_ManForEachCo( p, pObj, i )
-            if ( (i & 1) == fOdd )
-                Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-        Vec_IntFree( vNodes );
-        if ( fOdd )
-            *pp1 = pNew;
-        else
-            *pp0 = pNew;
-    }
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Collect nodes reachable from first/second half of outputs.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Vec_Int_t * Gia_ManCollectReach2( Gia_Man_t * p, int fSecond )
-{
-    int i, iDriver;
-    Vec_Int_t * vNodes = Vec_IntAlloc( Gia_ManObjNum(p) );
-    Gia_ManIncrementTravId( p );
-    Gia_ObjSetTravIdCurrent( p, Gia_ManConst0(p) );
-    Gia_ManForEachCoDriverId( p, iDriver, i )
-        if ( (i < Gia_ManCoNum(p)/2) ^ fSecond )
-            Gia_ManCollectDfs_rec( p, iDriver, vNodes );
-    return vNodes;
-}
-int Gia_ManDemiterTwoWords( Gia_Man_t * p, Gia_Man_t ** pp0, Gia_Man_t ** pp1 )
-{
-    Gia_Obj_t * pObj;
-    int i, fSecond;
-    assert( Gia_ManRegNum(p) == 0 );
-    assert( Gia_ManCoNum(p) % 2 == 0 );
-    *pp0 = *pp1 = NULL;
-    for ( fSecond = 0; fSecond < 2; fSecond++ )
-    {
-        Vec_Int_t * vNodes = Gia_ManCollectReach2( p, fSecond );
-        Gia_Man_t * pNew = Gia_ManStart( 1 + Gia_ManCiNum(p) + Vec_IntSize(vNodes) + Gia_ManCoNum(p)/2 );
-        pNew->pName = Abc_UtilStrsav( p->pName );
-        pNew->pSpec = Abc_UtilStrsav( p->pSpec );
-        Gia_ManConst0(p)->Value = 0;
-        Gia_ManForEachPi( p, pObj, i )
-            pObj->Value = Gia_ManAppendCi( pNew );
-        Gia_ManForEachObjVec( vNodes, p, pObj, i )
-            pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
-        Gia_ManForEachCo( p, pObj, i )
-            if ( (i < Gia_ManCoNum(p)/2) ^ fSecond )
-                Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
-        Vec_IntFree( vNodes );
-        if ( fSecond )
-            *pp1 = pNew;
-        else
-            *pp0 = pNew;
-    }
-    return 1;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-