自学教程：C++ Aig_ObjFanin0函数代码示例

/**Function*************************************************************  Synopsis    [Replaces node with a buffer fanin by a node without them.]  Description []                 SideEffects []  SeeAlso     []***********************************************************************/void Aig_NodeFixBufferFanins( Aig_Man_t * p, Aig_Obj_t * pObj, int fNodesOnly, int fUpdateLevel ){    Aig_Obj_t * pFanReal0, * pFanReal1, * pResult;    p->nBufFixes++;    if ( Aig_ObjIsPo(pObj) )    {        assert( Aig_ObjIsBuf(Aig_ObjFanin0(pObj)) );        pFanReal0 = Aig_ObjReal_rec( Aig_ObjChild0(pObj) );        assert( Aig_ObjPhaseReal(Aig_ObjChild0(pObj)) == Aig_ObjPhaseReal(pFanReal0) );        Aig_ObjPatchFanin0( p, pObj, pFanReal0 );        return;    }    assert( Aig_ObjIsNode(pObj) );    assert( Aig_ObjIsBuf(Aig_ObjFanin0(pObj)) || Aig_ObjIsBuf(Aig_ObjFanin1(pObj)) );    // get the real fanins    pFanReal0 = Aig_ObjReal_rec( Aig_ObjChild0(pObj) );    pFanReal1 = Aig_ObjReal_rec( Aig_ObjChild1(pObj) );    // get the new node    if ( Aig_ObjIsNode(pObj) )        pResult = Aig_Oper( p, pFanReal0, pFanReal1, Aig_ObjType(pObj) );//    else if ( Aig_ObjIsLatch(pObj) )//        pResult = Aig_Latch( p, pFanReal0, Aig_ObjInit(pObj) );    else         assert( 0 );    // replace the node with buffer by the node without buffer    Aig_ObjReplace( p, pObj, pResult, fNodesOnly, fUpdateLevel );}

/**Function*************************************************************  Synopsis    [Checks if node with the given attributes is in the hash table.]  Description []                 SideEffects []  SeeAlso     []***********************************************************************/Aig_Obj_t * Aig_TableLookup( Aig_Man_t * p, Aig_Obj_t * pGhost ){    Aig_Obj_t * pEntry;    assert( !Aig_IsComplement(pGhost) );    if ( pGhost->Type == AIG_OBJ_LATCH )    {        assert( Aig_ObjChild0(pGhost) && Aig_ObjChild1(pGhost) == NULL );        if ( !Aig_ObjRefs(Aig_ObjFanin0(pGhost)) )            return NULL;    }    else    {        assert( pGhost->Type == AIG_OBJ_AND );        assert( Aig_ObjChild0(pGhost) && Aig_ObjChild1(pGhost) );        assert( Aig_ObjFanin0(pGhost)->Id < Aig_ObjFanin1(pGhost)->Id );        if ( !Aig_ObjRefs(Aig_ObjFanin0(pGhost)) || !Aig_ObjRefs(Aig_ObjFanin1(pGhost)) )            return NULL;    }    for ( pEntry = p->pTable[Aig_Hash(pGhost, p->nTableSize)]; pEntry; pEntry = pEntry->pNext )    {        if ( Aig_ObjChild0(pEntry) == Aig_ObjChild0(pGhost) &&              Aig_ObjChild1(pEntry) == Aig_ObjChild1(pGhost) &&              Aig_ObjType(pEntry) == Aig_ObjType(pGhost) )            return pEntry;    }    return NULL;}

/**Function*************************************************************  Synopsis    [Creates the canonical form of the node.]  Description []  SideEffects []  SeeAlso     []***********************************************************************/Aig_Obj_t * Aig_CanonPair_rec( Aig_Man_t * p, Aig_Obj_t * pGhost ){    Aig_Obj_t * pResult, * pLat0, * pLat1;    int fCompl0, fCompl1;    Aig_Type_t Type;    assert( Aig_ObjIsNode(pGhost) );    // consider the case when the pair is canonical    if ( !Aig_ObjIsLatch(Aig_ObjFanin0(pGhost)) || !Aig_ObjIsLatch(Aig_ObjFanin1(pGhost)) )    {        if ( (pResult = Aig_TableLookup( p, pGhost )) )            return pResult;        return Aig_ObjCreate( p, pGhost );    }    /// remember the latches    pLat0 = Aig_ObjFanin0(pGhost);    pLat1 = Aig_ObjFanin1(pGhost);    // remember type and compls    Type = Aig_ObjType(pGhost);    fCompl0 = Aig_ObjFaninC0(pGhost);    fCompl1 = Aig_ObjFaninC1(pGhost);    // call recursively    pResult = Aig_Oper( p, Aig_NotCond(Aig_ObjChild0(pLat0), fCompl0), Aig_NotCond(Aig_ObjChild0(pLat1), fCompl1), Type );    // build latch on top of this    return Aig_Latch( p, pResult, (Type == AIG_OBJ_AND)? fCompl0 & fCompl1 : fCompl0 ^ fCompl1 );}

/**Function*************************************************************  Synopsis    [Constrains one node in the SAT solver.]  Description []                 SideEffects []  SeeAlso     []***********************************************************************/int Ssw_NodeIsConstrained( Ssw_Man_t * p, Aig_Obj_t * pPoObj ){    int RetValue, Lit;    Ssw_CnfNodeAddToSolver( p->pMSat, Aig_ObjFanin0(pPoObj) );    // add constraint A = 1  ---->  A    Lit = toLitCond( Ssw_ObjSatNum(p->pMSat,Aig_ObjFanin0(pPoObj)), !Aig_ObjFaninC0(pPoObj) );    if ( p->pPars->fPolarFlip )    {        if ( Aig_ObjFanin0(pPoObj)->fPhase )  Lit = lit_neg( Lit );    }    RetValue = sat_solver_addclause( p->pMSat->pSat, &Lit, &Lit + 1 );    assert( RetValue );    return 1;}

/**Function*************************************************************  Synopsis    [Performs one retiming step backward.]  Description [Returns the pointer to node after retiming.]                 SideEffects [Remember to run Aig_ManSetCioIds() in advance.]  SeeAlso     []***********************************************************************/Aig_Obj_t * Saig_ManRetimeNodeBwd( Aig_Man_t * p, Aig_Obj_t * pObjLo ){    Aig_Obj_t * pFanin0, * pFanin1;    Aig_Obj_t * pLo0New, * pLo1New;    Aig_Obj_t * pLi0New, * pLi1New;    Aig_Obj_t * pObj, * pObjNew, * pObjLi;    int fCompl0, fCompl1;    assert( Saig_ManRegNum(p) > 0 );    assert( Aig_ObjCioId(pObjLo) > 0 );    assert( Saig_ObjIsLo(p, pObjLo) );    // get the corresponding latch input    pObjLi = Saig_ManLi( p, Aig_ObjCioId(pObjLo) - Saig_ManPiNum(p) );    // get the node    pObj = Aig_ObjFanin0(pObjLi);    if ( !Aig_ObjIsNode(pObj) )        return NULL;    // get the fanins    pFanin0 = Aig_ObjFanin0(pObj);    pFanin1 = Aig_ObjFanin1(pObj);    // get the complemented attributes of the fanins    fCompl0 = Aig_ObjFaninC0(pObj) ^ Aig_ObjFaninC0(pObjLi);    fCompl1 = Aig_ObjFaninC1(pObj) ^ Aig_ObjFaninC0(pObjLi);    // create latch inputs    pLi0New = Aig_ObjCreateCo( p, Aig_NotCond(pFanin0, fCompl0) );    pLi0New->CioId = Aig_ManCoNum(p) - 1;    pLi1New = Aig_ObjCreateCo( p, Aig_NotCond(pFanin1, fCompl1) );    pLi1New->CioId = Aig_ManCoNum(p) - 1;    // create latch outputs    pLo0New = Aig_ObjCreateCi(p);    pLo0New->CioId = Aig_ManCiNum(p) - 1;    pLo1New = Aig_ObjCreateCi(p);    pLo1New->CioId = Aig_ManCiNum(p) - 1;    pLo0New = Aig_NotCond( pLo0New, fCompl0 );    pLo1New = Aig_NotCond( pLo1New, fCompl1 );    p->nRegs += 2;    // create node    pObjNew = Aig_And( p, pLo0New, pLo1New );//    assert( pObjNew->fPhase == 0 );    return pObjNew;}

// procedure to detect an EXOR gatestatic inline int Aig_ObjIsExorType( Aig_Obj_t * p0, Aig_Obj_t * p1, Aig_Obj_t ** ppFan0, Aig_Obj_t ** ppFan1 ){    if ( !Aig_IsComplement(p0) || !Aig_IsComplement(p1) )        return 0;    p0 = Aig_Regular(p0);    p1 = Aig_Regular(p1);    if ( !Aig_ObjIsAnd(p0) || !Aig_ObjIsAnd(p1) )        return 0;    if ( Aig_ObjFanin0(p0) != Aig_ObjFanin0(p1) || Aig_ObjFanin1(p0) != Aig_ObjFanin1(p1) )        return 0;    if ( Aig_ObjFaninC0(p0) == Aig_ObjFaninC0(p1) || Aig_ObjFaninC1(p0) == Aig_ObjFaninC1(p1) )        return 0;    *ppFan0 = Aig_ObjChild0(p0);    *ppFan1 = Aig_ObjChild1(p0);    return 1;}

/**Function*************************************************************  Synopsis    [Handles choices as additional combinational outputs.]  Description []                 SideEffects []  SeeAlso     []***********************************************************************/Gia_Man_t * Gia_ManFromAigSwitch( Aig_Man_t * p ){    Gia_Man_t * pNew;    Aig_Obj_t * pObj;    int i;    // create the new manager    pNew = Gia_ManStart( Aig_ManObjNum(p) );    pNew->pName = Gia_UtilStrsav( p->pName );    pNew->nConstrs = p->nConstrs;    // create the PIs    Aig_ManCleanData( p );    Aig_ManConst1(p)->iData = 1;    Aig_ManForEachPi( p, pObj, i )        pObj->iData = Gia_ManAppendCi( pNew );    // add POs corresponding to the nodes with choices    Aig_ManForEachNode( p, pObj, i )        if ( Aig_ObjRefs(pObj) == 0 )        {            Gia_ManFromAig_rec( pNew, p, pObj );                    Gia_ManAppendCo( pNew, pObj->iData );        }    // add logic for the POs    Aig_ManForEachPo( p, pObj, i )        Gia_ManFromAig_rec( pNew, p, Aig_ObjFanin0(pObj) );            Aig_ManForEachPo( p, pObj, i )        pObj->iData = Gia_ManAppendCo( pNew, Gia_ObjChild0Copy(pObj) );    Gia_ManSetRegNum( pNew, Aig_ManRegNum(p) );    return pNew;}

/**Function*************************************************************  Synopsis    [Duplicates AIG in the DFS order.]  Description []                 SideEffects []  SeeAlso     []***********************************************************************/Gia_Man_t * Gia_ManFromAig( Aig_Man_t * p ){    Gia_Man_t * pNew;    Aig_Obj_t * pObj;    int i;    // create the new manager    pNew = Gia_ManStart( Aig_ManObjNum(p) );    pNew->pName = Gia_UtilStrsav( p->pName );    pNew->nConstrs = p->nConstrs;    // create room to store equivalences    if ( p->pEquivs )        pNew->pNexts = ABC_CALLOC( int, Aig_ManObjNum(p) );    // create the PIs    Aig_ManCleanData( p );    Aig_ManConst1(p)->iData = 1;    Aig_ManForEachPi( p, pObj, i )        pObj->iData = Gia_ManAppendCi( pNew );    // add logic for the POs    Aig_ManForEachPo( p, pObj, i )        Gia_ManFromAig_rec( pNew, p, Aig_ObjFanin0(pObj) );            Aig_ManForEachPo( p, pObj, i )        Gia_ManAppendCo( pNew, Gia_ObjChild0Copy(pObj) );    Gia_ManSetRegNum( pNew, Aig_ManRegNum(p) );    if ( pNew->pNexts )        Gia_ManDeriveReprs( pNew );    return pNew;}

Gia_Man_t * Gia_ManFromAigChoices( Aig_Man_t * p ){    Gia_Man_t * pNew;    Aig_Obj_t * pObj;    int i;    assert( p->pEquivs != NULL );    // create the new manager    pNew = Gia_ManStart( Aig_ManObjNum(p) );    pNew->pName = Abc_UtilStrsav( p->pName );    pNew->pSpec = Abc_UtilStrsav( p->pSpec );    pNew->nConstrs = p->nConstrs;    // create room to store equivalences    pNew->pSibls = ABC_CALLOC( int, Aig_ManObjNum(p) );    // create the PIs    Aig_ManCleanData( p );    Aig_ManConst1(p)->iData = 1;    Aig_ManForEachCi( p, pObj, i )        pObj->iData = Gia_ManAppendCi( pNew );    // add logic for the POs    Aig_ManForEachCo( p, pObj, i )        Gia_ManFromAigChoices_rec( pNew, p, Aig_ObjFanin0(pObj) );            Aig_ManForEachCo( p, pObj, i )        Gia_ManAppendCo( pNew, Gia_ObjChild0Copy(pObj) );    Gia_ManSetRegNum( pNew, Aig_ManRegNum(p) );    assert( Gia_ManObjNum(pNew) == Aig_ManObjNum(p) );    return pNew;}

 // add fanouts Aig_ManForEachObj( p, pObj, i ) {     if ( Aig_ObjChild0(pObj) )         Aig_ObjSetFanoutStatic( Aig_ObjFanin0(pObj), pObj );     if ( Aig_ObjChild1(pObj) )         Aig_ObjSetFanoutStatic( Aig_ObjFanin1(pObj), pObj ); }

Aig_Obj_t *readLiveSignal_k( Aig_Man_t *pAig, int liveIndex_k ){	Aig_Obj_t *pObj;	pObj = Aig_ManCo( pAig, liveIndex_k );	return Aig_NotCond((Aig_Obj_t *)Aig_ObjFanin0(pObj), Aig_ObjFaninC0(pObj));}

ABC_NAMESPACE_IMPL_START///////////////////////////////////////////////////////////////////////////                        DECLARATIONS                              //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////                     FUNCTION DEFINITIONS                         ////////////////////////////////////////////////////////////////////////////**Function*************************************************************  Synopsis    [Recursively converts AIG from Aig_Man_t into Hop_Obj_t.]  Description []                 SideEffects []  SeeAlso     []***********************************************************************/void Abc_MfsConvertAigToHop_rec( Aig_Obj_t * pObj, Hop_Man_t * pHop ){    assert( !Aig_IsComplement(pObj) );    if ( pObj->pData )        return;    Abc_MfsConvertAigToHop_rec( Aig_ObjFanin0(pObj), pHop );     Abc_MfsConvertAigToHop_rec( Aig_ObjFanin1(pObj), pHop );    pObj->pData = Hop_And( pHop, (Hop_Obj_t *)Aig_ObjChild0Copy(pObj), (Hop_Obj_t *)Aig_ObjChild1Copy(pObj) );     assert( !Hop_IsComplement((Hop_Obj_t *)pObj->pData) );}

/**Function*************************************************************  Synopsis    [Converts AIG from Aig_Man_t into Hop_Obj_t.]  Description [Assumes that Aig_Man_t has exactly one primary outputs.  Returns the pointer to the root node (Hop_Obj_t) in Hop_Man_t.]                 SideEffects []  SeeAlso     []***********************************************************************/Hop_Obj_t * Abc_MfsConvertAigToHop( Aig_Man_t * pMan, Hop_Man_t * pHop ){    Aig_Obj_t * pRoot, * pObj;    int i;    assert( Aig_ManPoNum(pMan) == 1 );    pRoot = Aig_ManPo( pMan, 0 );    // check the case of a constant    if ( Aig_ObjIsConst1( Aig_ObjFanin0(pRoot) ) )        return Hop_NotCond( Hop_ManConst1(pHop), Aig_ObjFaninC0(pRoot) );    // set the PI mapping    Aig_ManCleanData( pMan );    Aig_ManForEachPi( pMan, pObj, i )        pObj->pData = Hop_IthVar( pHop, i );    // construct the AIG    Abc_MfsConvertAigToHop_rec( Aig_ObjFanin0(pRoot), pHop );    return Hop_NotCond( (Hop_Obj_t *)Aig_ObjFanin0(pRoot)->pData, Aig_ObjFaninC0(pRoot) );}

ABC_NAMESPACE_IMPL_START///////////////////////////////////////////////////////////////////////////                        DECLARATIONS                              ///////////////////////////////////////////////////////////////////////////static inline int Gia_ObjChild0Copy( Aig_Obj_t * pObj )  { return Gia_LitNotCond( Aig_ObjFanin0(pObj)->iData, Aig_ObjFaninC0(pObj) ); }

/**Function*************************************************************  Synopsis    [Performs clock-gating for the AIG.]  Description []                 SideEffects []  SeeAlso     []***********************************************************************/void Cgt_ClockGatingRangeCheck( Cgt_Man_t * p, int iStart, int nOutputs ){    Vec_Ptr_t * vNodes = p->vFanout;    Aig_Obj_t * pMiter, * pCand, * pMiterFrame, * pCandFrame, * pMiterPart, * pCandPart;    int i, k, RetValue, nCalls;    assert( Vec_VecSize(p->vGatesAll) == Aig_ManPoNum(p->pFrame) );    // go through all the registers inputs of this range    for ( i = iStart; i < iStart + nOutputs; i++ )    {        nCalls = p->nCalls;        pMiter = Saig_ManLi( p->pAig, i );        Cgt_ManDetectCandidates( p->pAig, Aig_ObjFanin0(pMiter), p->pPars->nLevelMax, vNodes );        // go through the candidates of this PO        Vec_PtrForEachEntry( Aig_Obj_t *, vNodes, pCand, k )        {            // get the corresponding nodes from the frames            pCandFrame  = (Aig_Obj_t *)pCand->pData;            pMiterFrame = (Aig_Obj_t *)pMiter->pData;            // get the corresponding nodes from the part            pCandPart   = (Aig_Obj_t *)pCandFrame->pData;            pMiterPart  = (Aig_Obj_t *)pMiterFrame->pData;            // try direct polarity            if ( Cgt_SimulationFilter( p, pCandPart, pMiterPart ) )            {                RetValue = Cgt_CheckImplication( p, pCandPart, pMiterPart );                if ( RetValue == 1 )                {                    Vec_VecPush( p->vGatesAll, i, pCand );                    continue;                }                if ( RetValue == 0 )                    Cgt_SimulationRecord( p );            }            else                p->nCallsFiltered++;            // try reverse polarity            if ( Cgt_SimulationFilter( p, Aig_Not(pCandPart), pMiterPart ) )            {                RetValue = Cgt_CheckImplication( p, Aig_Not(pCandPart), pMiterPart );                if ( RetValue == 1 )                {                    Vec_VecPush( p->vGatesAll, i, Aig_Not(pCand) );                    continue;                }                if ( RetValue == 0 )                    Cgt_SimulationRecord( p );            }            else                p->nCallsFiltered++;        }        if ( p->pPars->fVerbose )        {//            printf( "Flop %3d : Cand = %4d. Gate = %4d. SAT calls = %3d./n", //                i, Vec_PtrSize(vNodes), Vec_PtrSize(Vec_VecEntry(p->vGatesAll, i)), p->nCalls-nCalls );        }    }

/**Function*************************************************************  Synopsis    [Replaces one object by another.]  Description [The new object (pObjNew) should be used instead of the old   object (pObjOld). If the new object is complemented or used, the buffer   is added and the new object remains in the manager; otherwise, the new  object is deleted.]                 SideEffects []  SeeAlso     []***********************************************************************/void Aig_ObjReplace( Aig_Man_t * p, Aig_Obj_t * pObjOld, Aig_Obj_t * pObjNew, int fNodesOnly, int fUpdateLevel ){    Aig_Obj_t * pObjNewR = Aig_Regular(pObjNew);    // the object to be replaced cannot be complemented    assert( !Aig_IsComplement(pObjOld) );    // the object to be replaced cannot be a terminal    assert( !Aig_ObjIsPi(pObjOld) && !Aig_ObjIsPo(pObjOld) );    // the object to be used cannot be a buffer or a PO    assert( !Aig_ObjIsBuf(pObjNewR) && !Aig_ObjIsPo(pObjNewR) );    // the object cannot be the same    assert( pObjOld != pObjNewR );    // make sure object is not pointing to itself    assert( pObjOld != Aig_ObjFanin0(pObjNewR) );    assert( pObjOld != Aig_ObjFanin1(pObjNewR) );    // recursively delete the old node - but leave the object there    pObjNewR->nRefs++;    Aig_ObjDelete_rec( p, pObjOld, 0 );    pObjNewR->nRefs--;    // if the new object is complemented or already used, create a buffer    p->nObjs[pObjOld->Type]--;    if ( Aig_IsComplement(pObjNew) || Aig_ObjRefs(pObjNew) > 0 || (fNodesOnly && !Aig_ObjIsNode(pObjNew)) )    {        pObjOld->Type = AIG_OBJ_BUF;        Aig_ObjConnect( p, pObjOld, pObjNew, NULL );        p->nBufReplaces++;    }    else    {        Aig_Obj_t * pFanin0 = pObjNew->pFanin0;        Aig_Obj_t * pFanin1 = pObjNew->pFanin1;        int LevelOld = pObjOld->Level;        pObjOld->Type = pObjNew->Type;        Aig_ObjDisconnect( p, pObjNew );        Aig_ObjConnect( p, pObjOld, pFanin0, pFanin1 );        // delete the new object        Aig_ObjDelete( p, pObjNew );        // update levels        if ( p->pFanData )        {            pObjOld->Level = LevelOld;            Aig_ManUpdateLevel( p, pObjOld );        }        if ( fUpdateLevel )        {            Aig_ObjClearReverseLevel( p, pObjOld );            Aig_ManUpdateReverseLevel( p, pObjOld );        }    }    p->nObjs[pObjOld->Type]++;    // store buffers if fanout is allocated    if ( p->pFanData && Aig_ObjIsBuf(pObjOld) )    {        Vec_PtrPush( p->vBufs, pObjOld );        p->nBufMax = AIG_MAX( p->nBufMax, Vec_PtrSize(p->vBufs) );        Aig_ManPropagateBuffers( p, fNodesOnly, fUpdateLevel );    }}

/**Function*************************************************************  Synopsis    [Checks if node with the given attributes is in the hash table.]  Description []                 SideEffects []  SeeAlso     []***********************************************************************/Aig_Obj_t * Aig_TableLookup( Aig_Man_t * p, Aig_Obj_t * pGhost ){    Aig_Obj_t * pEntry;    assert( !Aig_IsComplement(pGhost) );    assert( Aig_ObjIsNode(pGhost) );    assert( Aig_ObjChild0(pGhost) && Aig_ObjChild1(pGhost) );    assert( Aig_ObjFanin0(pGhost)->Id < Aig_ObjFanin1(pGhost)->Id );    if ( p->pTable == NULL || !Aig_ObjRefs(Aig_ObjFanin0(pGhost)) || !Aig_ObjRefs(Aig_ObjFanin1(pGhost)) )        return NULL;    for ( pEntry = p->pTable[Aig_Hash(pGhost, p->nTableSize)]; pEntry; pEntry = pEntry->pNext )    {        if ( Aig_ObjChild0(pEntry) == Aig_ObjChild0(pGhost) &&              Aig_ObjChild1(pEntry) == Aig_ObjChild1(pGhost) &&              Aig_ObjType(pEntry) == Aig_ObjType(pGhost) )            return pEntry;    }    return NULL;}

/**Function*************************************************************  Synopsis    []  Description []                 SideEffects []  SeeAlso     []***********************************************************************/void Llb_ManLabelLiCones_rec( Aig_Man_t * p, Aig_Obj_t * pObj ){    if ( pObj->fMarkB )        return;    pObj->fMarkB = 1;    assert( Aig_ObjIsNode(pObj) );    Llb_ManLabelLiCones_rec( p, Aig_ObjFanin0(pObj) );    Llb_ManLabelLiCones_rec( p, Aig_ObjFanin1(pObj) );}

// hashing the nodestatic unsigned long Aig_Hash( Aig_Obj_t * pObj, int TableSize ) {    unsigned long Key = Aig_ObjIsExor(pObj) * 1699;    Key ^= Aig_ObjFanin0(pObj)->Id * 7937;    Key ^= Aig_ObjFanin1(pObj)->Id * 2971;    Key ^= Aig_ObjFaninC0(pObj) * 911;    Key ^= Aig_ObjFaninC1(pObj) * 353;    return Key % TableSize;}

/**Function*************************************************************  Synopsis    [Duplicates the AIG manager recursively.]  Description []                 SideEffects []  SeeAlso     []***********************************************************************/Aig_Obj_t * Aig_ManDup_rec( Aig_Man_t * pNew, Aig_Man_t * p, Aig_Obj_t * pObj ){    if ( pObj->pData )        return pObj->pData;    Aig_ManDup_rec( pNew, p, Aig_ObjFanin0(pObj) );    if ( Aig_ObjIsBuf(pObj) )        return pObj->pData = Aig_ObjChild0Copy(pObj);    Aig_ManDup_rec( pNew, p, Aig_ObjFanin1(pObj) );    return pObj->pData = Aig_And( pNew, Aig_ObjChild0Copy(pObj), Aig_ObjChild1Copy(pObj) );}

/**Function*************************************************************  Synopsis    [Creates AIG for the window with constraints.]  Description []                 SideEffects []  SeeAlso     []***********************************************************************/Aig_Man_t * Abc_NtkConstructAig( Mfs_Man_t * p, Abc_Obj_t * pNode ){    Aig_Man_t * pMan;    Abc_Obj_t * pFanin;    Aig_Obj_t * pObjAig, * pPi, * pPo;    Vec_Int_t * vOuts;    int i, k, iOut;    // start the new manager    pMan = Aig_ManStart( 1000 );    // construct the root node's AIG cone    pObjAig = Abc_NtkConstructAig_rec( p, pNode, pMan );//    assert( Aig_ManConst1(pMan) == pObjAig );    Aig_ObjCreatePo( pMan, pObjAig );    if ( p->pCare )    {        // mark the care set        Aig_ManIncrementTravId( p->pCare );        Vec_PtrForEachEntry( Abc_Obj_t *, p->vSupp, pFanin, i )        {            pPi = Aig_ManPi( p->pCare, (int)(ABC_PTRUINT_T)pFanin->pData );            Aig_ObjSetTravIdCurrent( p->pCare, pPi );            pPi->pData = pFanin->pCopy;        }        // construct the constraints        Vec_PtrForEachEntry( Abc_Obj_t *, p->vSupp, pFanin, i )        {            vOuts = (Vec_Int_t *)Vec_PtrEntry( p->vSuppsInv, (int)(ABC_PTRUINT_T)pFanin->pData );            Vec_IntForEachEntry( vOuts, iOut, k )            {                pPo = Aig_ManPo( p->pCare, iOut );                if ( Aig_ObjIsTravIdCurrent( p->pCare, pPo ) )                    continue;                Aig_ObjSetTravIdCurrent( p->pCare, pPo );                if ( Aig_ObjFanin0(pPo) == Aig_ManConst1(p->pCare) )                    continue;                pObjAig = Abc_NtkConstructCare_rec( p->pCare, Aig_ObjFanin0(pPo), pMan );                if ( pObjAig == NULL )                    continue;                pObjAig = Aig_NotCond( pObjAig, Aig_ObjFaninC0(pPo) );                Aig_ObjCreatePo( pMan, pObjAig );            }        }

/**Function*************************************************************  Synopsis    [Create the array of literals to be written.]  Description []    SideEffects []  SeeAlso     []***********************************************************************/Vec_Int_t * Ioa_WriteAigerLiterals( Aig_Man_t * pMan ){    Vec_Int_t * vLits;    Aig_Obj_t * pObj, * pDriver;    int i;    vLits = Vec_IntAlloc( Aig_ManCoNum(pMan) );    Aig_ManForEachLiSeq( pMan, pObj, i )    {        pDriver = Aig_ObjFanin0(pObj);        Vec_IntPush( vLits, Ioa_ObjMakeLit( Ioa_ObjAigerNum(pDriver), Aig_ObjFaninC0(pObj) ^ (Ioa_ObjAigerNum(pDriver) == 0) ) );    }

/**Function*************************************************************  Synopsis    [Returns 1 if the cone of the node overlaps with the vector.]  Description []                 SideEffects []  SeeAlso     []***********************************************************************/Aig_Obj_t * Aig_ManDeriveNewCone_rec( Aig_Man_t * p, Aig_Obj_t * pNode ){    if ( Aig_ObjIsTravIdCurrent( p, pNode ) )        return (Aig_Obj_t *)pNode->pData;    Aig_ObjSetTravIdCurrent( p, pNode );    if ( Aig_ObjIsCi(pNode) )        return (Aig_Obj_t *)(pNode->pData = pNode);    Aig_ManDeriveNewCone_rec( p, Aig_ObjFanin0(pNode) );    Aig_ManDeriveNewCone_rec( p, Aig_ObjFanin1(pNode) );    return (Aig_Obj_t *)(pNode->pData = Aig_And( p, Aig_ObjChild0Copy(pNode), Aig_ObjChild1Copy(pNode) ));}

/**Function*************************************************************  Synopsis    [Replaces the first fanin of the node by the new fanin.]  Description []                 SideEffects []  SeeAlso     []***********************************************************************/void Aig_ObjPatchFanin0( Aig_Man_t * p, Aig_Obj_t * pObj, Aig_Obj_t * pFaninNew ){    Aig_Obj_t * pFaninOld;    assert( !Aig_IsComplement(pObj) );    assert( Aig_ObjIsPo(pObj) );    pFaninOld = Aig_ObjFanin0(pObj);    // decrement ref and remove fanout    if ( p->pFanData )        Aig_ObjRemoveFanout( p, pFaninOld, pObj );    Aig_ObjDeref( pFaninOld );    // update the fanin    pObj->pFanin0 = pFaninNew;    // increment ref and add fanout    if ( p->pFanData )        Aig_ObjAddFanout( p, Aig_ObjFanin0(pObj), pObj );    Aig_ObjRef( Aig_ObjFanin0(pObj) );    // get rid of old fanin    if ( !Aig_ObjIsPi(pFaninOld) && !Aig_ObjIsConst1(pFaninOld) && Aig_ObjRefs(pFaninOld) == 0 )        Aig_ObjDelete_rec( p, pFaninOld, 1 );}

/**Function*************************************************************  Synopsis    [Determine starting cut-points.]  Description []                 SideEffects []  SeeAlso     []***********************************************************************/void Llb_ManLabelLiCones( Aig_Man_t * p ){    Aig_Obj_t * pObj;    int i;    // mark const and PIs    Aig_ManConst1(p)->fMarkB = 1;    Aig_ManForEachPi( p, pObj, i )        pObj->fMarkB = 1;    // mark cones    Saig_ManForEachLi( p, pObj, i )        Llb_ManLabelLiCones_rec( p, Aig_ObjFanin0(pObj) );}