Renamed Aig_ManForEachPi/Po to be ...Ci/Co and Aig_ObjCreatePi/Po to be ...Ci/Co.

12 files changed, 46 insertions, 46 deletions

diff --git a/src/proof/fra/fraBmc.c b/src/proof/fra/fraBmc.c
index 7b4db3de..b0dd3c86 100644
--- a/src/proof/fra/fraBmc.c
+++ b/src/proof/fra/fraBmc.c
@@ -250,7 +250,7 @@ Aig_Man_t * Fra_BmcFrames( Fra_Bmc_t * p, int fKeepPos )
         Bmc_ObjSetFrames( Aig_ManConst1(p->pAig), f, Aig_ManConst1(pAigFrames) );
     for ( f = 0; f < p->nFramesAll; f++ )
         Aig_ManForEachPiSeq( p->pAig, pObj, i )
-            Bmc_ObjSetFrames( pObj, f, Aig_ObjCreatePi(pAigFrames) );
+            Bmc_ObjSetFrames( pObj, f, Aig_ObjCreateCi(pAigFrames) );
     // set initial state for the latches
     Aig_ManForEachLoSeq( p->pAig, pObj, i )
         Bmc_ObjSetFrames( pObj, 0, Aig_ManConst0(pAigFrames) );
@@ -283,7 +283,7 @@ Aig_Man_t * Fra_BmcFrames( Fra_Bmc_t * p, int fKeepPos )
     {
         for ( f = 0; f < p->nFramesAll; f++ )
             Aig_ManForEachPoSeq( p->pAig, pObj, i )
-                Aig_ObjCreatePo( pAigFrames, Bmc_ObjChild0Frames(pObj,f) );
+                Aig_ObjCreateCo( pAigFrames, Bmc_ObjChild0Frames(pObj,f) );
         Aig_ManCleanup( pAigFrames );
     }
     else
@@ -291,7 +291,7 @@ Aig_Man_t * Fra_BmcFrames( Fra_Bmc_t * p, int fKeepPos )
         // add POs to all the dangling nodes
         Aig_ManForEachObj( pAigFrames, pObjNew, i )
             if ( Aig_ObjIsNode(pObjNew) && pObjNew->nRefs == 0 )
-                Aig_ObjCreatePo( pAigFrames, pObjNew );
+                Aig_ObjCreateCo( pAigFrames, pObjNew );
     }
     // return the new manager
     return pAigFrames;
diff --git a/src/proof/fra/fraClass.c b/src/proof/fra/fraClass.c
index 67351f6d..f7850241 100644
--- a/src/proof/fra/fraClass.c
+++ b/src/proof/fra/fraClass.c
@@ -779,7 +779,7 @@ static inline void Fra_ClassesDeriveNode( Aig_Man_t * pManFraig, Aig_Obj_t * pOb
     pMiter = Aig_Exor( pManFraig, Aig_Regular(pObjNew), Aig_Regular(pObjReprNew) );
     pMiter = Aig_NotCond( pMiter, Aig_Regular(pMiter)->fPhase ^ Aig_IsComplement(pMiter) );
     pMiter = Aig_Not( pMiter );
-    Aig_ObjCreatePo( pManFraig, pMiter );
+    Aig_ObjCreateCo( pManFraig, pMiter );
 }
 
 /**Function*************************************************************
@@ -811,14 +811,14 @@ Aig_Man_t * Fra_ClassesDeriveAig( Fra_Cla_t * p, int nFramesK )
     Fra_ObjSetEqu( ppEquivs, Aig_ManConst1(p->pAig), Aig_ManConst1(pManFraig) );
     // create latches for the first frame
     Aig_ManForEachLoSeq( p->pAig, pObj, i )
-        Fra_ObjSetEqu( ppEquivs, pObj, Aig_ObjCreatePi(pManFraig) );
+        Fra_ObjSetEqu( ppEquivs, pObj, Aig_ObjCreateCi(pManFraig) );
     // add timeframes
     pLatches = ABC_ALLOC( Aig_Obj_t *, Aig_ManRegNum(p->pAig) );
     for ( f = 0; f < nFramesAll; f++ )
     {
         // create PIs for this frame
         Aig_ManForEachPiSeq( p->pAig, pObj, i )
-            Fra_ObjSetEqu( ppEquivs, pObj, Aig_ObjCreatePi(pManFraig) );
+            Fra_ObjSetEqu( ppEquivs, pObj, Aig_ObjCreateCi(pManFraig) );
         // set the constraints on the latch outputs
         Aig_ManForEachLoSeq( p->pAig, pObj, i )
             Fra_ClassesDeriveNode( pManFraig, pObj, ppEquivs );
diff --git a/src/proof/fra/fraClau.c b/src/proof/fra/fraClau.c
index 48640d1d..28e9e9b9 100644
--- a/src/proof/fra/fraClau.c
+++ b/src/proof/fra/fraClau.c
@@ -109,7 +109,7 @@ Vec_Int_t * Fra_ClauSaveOutputVars( Aig_Man_t * pMan, Cnf_Dat_t * pCnf )
     Aig_Obj_t * pObj;
     int i;
     vVars = Vec_IntAlloc( Aig_ManPoNum(pMan) );
-    Aig_ManForEachPo( pMan, pObj, i )
+    Aig_ManForEachCo( pMan, pObj, i )
         Vec_IntPush( vVars, pCnf->pVarNums[pObj->Id] );
     return vVars;
 }
@@ -131,7 +131,7 @@ Vec_Int_t * Fra_ClauSaveInputVars( Aig_Man_t * pMan, Cnf_Dat_t * pCnf, int nStar
     Aig_Obj_t * pObj;
     int i;
     vVars = Vec_IntAlloc( Aig_ManPiNum(pMan) - nStarting );
-    Aig_ManForEachPi( pMan, pObj, i )
+    Aig_ManForEachCi( pMan, pObj, i )
     {
         if ( i < nStarting )
             continue;
diff --git a/src/proof/fra/fraClaus.c b/src/proof/fra/fraClaus.c
index e71219b5..f27c63ce 100644
--- a/src/proof/fra/fraClaus.c
+++ b/src/proof/fra/fraClaus.c
@@ -1565,7 +1565,7 @@ void Fra_ClausWriteIndClauses( Clu_Man_t * p )
             pLiteral = Fra_ClausGetLiteral( p, pVar2Id, pStart[k] );
             pClause = Aig_Or( pNew, pClause, pLiteral );
         }
-        Aig_ObjCreatePo( pNew, pClause );
+        Aig_ObjCreateCo( pNew, pClause );
         Beg = End;
     }
     ABC_FREE( pVar2Id );
diff --git a/src/proof/fra/fraCore.c b/src/proof/fra/fraCore.c
index d3b60ab7..1969b36d 100644
--- a/src/proof/fra/fraCore.c
+++ b/src/proof/fra/fraCore.c
@@ -193,12 +193,12 @@ void Fra_FraigVerifyCounterEx( Fra_Man_t * p, Vec_Int_t * vCex )
         assert( !pObj->fMarkB );
     // simulate the cex through the AIG
     Aig_ManConst1(p->pManAig)->fMarkB = 1;
-    Aig_ManForEachPi( p->pManAig, pObj, i )
+    Aig_ManForEachCi( p->pManAig, pObj, i )
         pObj->fMarkB = Vec_IntEntry(vCex, i);
     Aig_ManForEachNode( p->pManAig, pObj, i )
         pObj->fMarkB = (Aig_ObjFanin0(pObj)->fMarkB ^ Aig_ObjFaninC0(pObj)) & 
                        (Aig_ObjFanin1(pObj)->fMarkB ^ Aig_ObjFaninC1(pObj));
-    Aig_ManForEachPo( p->pManAig, pObj, i )
+    Aig_ManForEachCo( p->pManAig, pObj, i )
         pObj->fMarkB = Aig_ObjFanin0(pObj)->fMarkB ^ Aig_ObjFaninC0(pObj);
     // check if the classes hold
     Vec_PtrForEachEntry( Aig_Obj_t *, p->pCla->vClasses1, pObj, i )
diff --git a/src/proof/fra/fraHot.c b/src/proof/fra/fraHot.c
index 29c9c33d..03dd468a 100644
--- a/src/proof/fra/fraHot.c
+++ b/src/proof/fra/fraHot.c
@@ -402,9 +402,9 @@ Aig_Man_t * Fra_OneHotCreateExdc( Fra_Man_t * p, Vec_Int_t * vOneHots )
     int i, Out1, Out2, nTruePis;
     pNew = Aig_ManStart( Vec_IntSize(vOneHots)/2 );
 //    for ( i = 0; i < Aig_ManRegNum(p->pManAig); i++ )
-//        Aig_ObjCreatePi(pNew);
-    Aig_ManForEachPi( p->pManAig, pObj, i )
-        Aig_ObjCreatePi(pNew);
+//        Aig_ObjCreateCi(pNew);
+    Aig_ManForEachCi( p->pManAig, pObj, i )
+        Aig_ObjCreateCi(pNew);
     nTruePis = Aig_ManPiNum(p->pManAig) - Aig_ManRegNum(p->pManAig);
     for ( i = 0; i < Vec_IntSize(vOneHots); i += 2 )
     {
@@ -417,7 +417,7 @@ Aig_Man_t * Fra_OneHotCreateExdc( Fra_Man_t * p, Vec_Int_t * vOneHots )
         pObj1 = Aig_NotCond( pObj1, Fra_LitSign(Out1) );
         pObj2 = Aig_NotCond( pObj2, Fra_LitSign(Out2) );
         pObj  = Aig_Or( pNew, pObj1, pObj2 );
-        Aig_ObjCreatePo( pNew, pObj );
+        Aig_ObjCreateCo( pNew, pObj );
     }
     Aig_ManCleanup(pNew);
 //    printf( "Created AIG with %d nodes and %d outputs.\n", Aig_ManNodeNum(pNew), Aig_ManPoNum(pNew) );
diff --git a/src/proof/fra/fraImp.c b/src/proof/fra/fraImp.c
index 9877ceaa..de24f179 100644
--- a/src/proof/fra/fraImp.c
+++ b/src/proof/fra/fraImp.c
@@ -717,7 +717,7 @@ void Fra_ImpRecordInManager( Fra_Man_t * p, Aig_Man_t * pNew )
         pMiter = Aig_Or( pNew, 
             Aig_NotCond((Aig_Obj_t *)pLeft->pData, !pLeft->fPhase), 
             Aig_NotCond((Aig_Obj_t *)pRight->pData, pRight->fPhase) ); 
-        Aig_ObjCreatePo( pNew, pMiter );
+        Aig_ObjCreateCo( pNew, pMiter );
     }
     pNew->nAsserts = Aig_ManPoNum(pNew) - nPosOld;
 }
diff --git a/src/proof/fra/fraInd.c b/src/proof/fra/fraInd.c
index 1224bab3..b8a1e6bf 100644
--- a/src/proof/fra/fraInd.c
+++ b/src/proof/fra/fraInd.c
@@ -112,7 +112,7 @@ static inline void Fra_FramesConstrainNode( Aig_Man_t * pManFraig, Aig_Obj_t * p
     pMiter = Aig_Exor( pManFraig, pObjNew, pObjReprNew );
     pMiter = Aig_NotCond( pMiter, !Aig_ObjPhaseReal(pMiter) );
     assert( Aig_ObjPhaseReal(pMiter) == 1 );
-    Aig_ObjCreatePo( pManFraig, pMiter );
+    Aig_ObjCreateCo( pManFraig, pMiter );
 }
 
 /**Function*************************************************************
@@ -145,10 +145,10 @@ Aig_Man_t * Fra_FramesWithClasses( Fra_Man_t * p )
         Fra_ObjSetFraig( Aig_ManConst1(p->pManAig), f, Aig_ManConst1(pManFraig) );
     for ( f = 0; f < p->nFramesAll; f++ )
         Aig_ManForEachPiSeq( p->pManAig, pObj, i )
-            Fra_ObjSetFraig( pObj, f, Aig_ObjCreatePi(pManFraig) );
+            Fra_ObjSetFraig( pObj, f, Aig_ObjCreateCi(pManFraig) );
     // create latches for the first frame
     Aig_ManForEachLoSeq( p->pManAig, pObj, i )
-        Fra_ObjSetFraig( pObj, 0, Aig_ObjCreatePi(pManFraig) );
+        Fra_ObjSetFraig( pObj, 0, Aig_ObjCreateCi(pManFraig) );
 
     // add timeframes
 //    pManFraig->fAddStrash = 1;
@@ -173,7 +173,7 @@ Aig_Man_t * Fra_FramesWithClasses( Fra_Man_t * p )
     pManFraig->nAsserts = Aig_ManPoNum(pManFraig);
     // add the POs for the latch outputs of the last frame
     Aig_ManForEachLoSeq( p->pManAig, pObj, i )
-        Aig_ObjCreatePo( pManFraig, Fra_ObjFraig(pObj,p->nFramesAll-1) );
+        Aig_ObjCreateCo( pManFraig, Fra_ObjFraig(pObj,p->nFramesAll-1) );
 
     // remove dangling nodes
     Aig_ManCleanup( pManFraig );
diff --git a/src/proof/fra/fraLcr.c b/src/proof/fra/fraLcr.c
index 238e3096..d24b37f6 100644
--- a/src/proof/fra/fraLcr.c
+++ b/src/proof/fra/fraLcr.c
@@ -134,7 +134,7 @@ void Lcr_ManFree( Fra_Lcr_t * p )
     int i;
     if ( p->fVerbose )
         Lcr_ManPrint( p );
-    Aig_ManForEachPi( p->pAig, pObj, i )
+    Aig_ManForEachCi( p->pAig, pObj, i )
         pObj->pNext = NULL;
     Vec_PtrFree( p->vFraigs );
     if ( p->pCla  )     Fra_ClassesStop( p->pCla );
@@ -162,7 +162,7 @@ Fra_Man_t * Fra_LcrAigPrepare( Aig_Man_t * pAig )
     int i;
     p = ABC_ALLOC( Fra_Man_t, 1 );
     memset( p, 0, sizeof(Fra_Man_t) );
-//    Aig_ManForEachPi( pAig, pObj, i )
+//    Aig_ManForEachCi( pAig, pObj, i )
     Aig_ManForEachObj( pAig, pObj, i )
         pObj->pData = p;
     return p;
@@ -183,7 +183,7 @@ void Fra_LcrAigPrepareTwo( Aig_Man_t * pAig, Fra_Man_t * p )
 {
     Aig_Obj_t * pObj;
     int i;
-    Aig_ManForEachPi( pAig, pObj, i )
+    Aig_ManForEachCi( pAig, pObj, i )
         pObj->pData = p;
 }
 
@@ -300,7 +300,7 @@ Aig_Man_t * Fra_LcrDeriveAigForPartitioning( Fra_Lcr_t * pLcr )
     Aig_Obj_t * pObj, * pObjPo, * pObjNew, ** ppClass, * pMiter;
     int i, c, Offset;
     // remember the numbers of the inputs of the original AIG
-    Aig_ManForEachPi( pLcr->pAig, pObj, i )
+    Aig_ManForEachCi( pLcr->pAig, pObj, i )
     {
         pObj->pData = pLcr;
         pObj->pNext = (Aig_Obj_t *)(long)i;
@@ -321,7 +321,7 @@ Aig_Man_t * Fra_LcrDeriveAigForPartitioning( Fra_Lcr_t * pLcr )
             pObjNew = Fra_LcrManDup_rec( pNew, pLcr->pAig, Aig_ObjFanin0(pObjPo) );
             pMiter  = Aig_Exor( pNew, pMiter, pObjNew );
         }
-        Aig_ObjCreatePo( pNew, pMiter );
+        Aig_ObjCreateCo( pNew, pMiter );
     }
     // go over the constant candidates
     Vec_PtrForEachEntry( Aig_Obj_t *, pLcr->pCla->vClasses1, pObj, i )
@@ -329,7 +329,7 @@ Aig_Man_t * Fra_LcrDeriveAigForPartitioning( Fra_Lcr_t * pLcr )
         assert( Aig_ObjIsPi(pObj) );
         pObjPo = Aig_ManPo( pLcr->pAig, Offset+(long)pObj->pNext );
         pMiter = Fra_LcrManDup_rec( pNew, pLcr->pAig, Aig_ObjFanin0(pObjPo) );
-        Aig_ObjCreatePo( pNew, pMiter );
+        Aig_ObjCreateCo( pNew, pMiter );
     }
     return pNew;
 }
@@ -403,7 +403,7 @@ Aig_Obj_t * Fra_LcrCreatePart_rec( Fra_Cla_t * pCla, Aig_Man_t * pNew, Aig_Man_t
 //        Aig_Obj_t * pRepr = Fra_ClassObjRepr(pObj);
         Aig_Obj_t * pRepr = pCla->pMemRepr[pObj->Id];
         if ( pRepr == NULL )
-            pObj->pData = Aig_ObjCreatePi( pNew );
+            pObj->pData = Aig_ObjCreateCi( pNew );
         else
         {
             pObj->pData = Fra_LcrCreatePart_rec( pCla, pNew, p, pRepr );
@@ -447,7 +447,7 @@ Aig_Man_t * Fra_LcrCreatePart( Fra_Lcr_t * p, Vec_Int_t * vPart )
         }
         else
             pObjNew = Aig_ManConst1( pNew );
-        Aig_ObjCreatePo( pNew, pObjNew ); 
+        Aig_ObjCreateCo( pNew, pObjNew ); 
     }
     return pNew;
 }
diff --git a/src/proof/fra/fraMan.c b/src/proof/fra/fraMan.c
index 90e8b762..67832f83 100644
--- a/src/proof/fra/fraMan.c
+++ b/src/proof/fra/fraMan.c
@@ -187,8 +187,8 @@ Aig_Man_t * Fra_ManPrepareComb( Fra_Man_t * p )
     pManFraig->nAsserts = p->pManAig->nAsserts;
     // set the pointers to the available fraig nodes
     Fra_ObjSetFraig( Aig_ManConst1(p->pManAig), 0, Aig_ManConst1(pManFraig) );
-    Aig_ManForEachPi( p->pManAig, pObj, i )
-        Fra_ObjSetFraig( pObj, 0, Aig_ObjCreatePi(pManFraig) );
+    Aig_ManForEachCi( p->pManAig, pObj, i )
+        Fra_ObjSetFraig( pObj, 0, Aig_ObjCreateCi(pManFraig) );
     // set the pointers to the manager
     Aig_ManForEachObj( pManFraig, pObj, i )
         pObj->pData = p;
@@ -219,8 +219,8 @@ void Fra_ManFinalizeComb( Fra_Man_t * p )
     Aig_Obj_t * pObj;
     int i;
     // add the POs
-    Aig_ManForEachPo( p->pManAig, pObj, i )
-        Aig_ObjCreatePo( p->pManFraig, Fra_ObjChild0Fra(pObj,0) );
+    Aig_ManForEachCo( p->pManAig, pObj, i )
+        Aig_ObjCreateCo( p->pManFraig, Fra_ObjChild0Fra(pObj,0) );
     // postprocess
     Aig_ManCleanMarkB( p->pManFraig );
 }
diff --git a/src/proof/fra/fraPart.c b/src/proof/fra/fraPart.c
index e9739f97..6594ac0b 100644
--- a/src/proof/fra/fraPart.c
+++ b/src/proof/fra/fraPart.c
@@ -64,7 +64,7 @@ clk = clock();
     vSupps = (Vec_Vec_t *)Aig_ManSupports( p );
 ABC_PRT( "Supports", clock() - clk );
     // remove last entry
-    Aig_ManForEachPo( p, pObj, i )
+    Aig_ManForEachCo( p, pObj, i )
     {
         vSup = Vec_VecEntryInt( vSupps, i );
         Vec_IntPop( vSup );
@@ -75,7 +75,7 @@ ABC_PRT( "Supports", clock() - clk );
     // create reverse supports
 clk = clock();
     vSuppsIn = Vec_VecStart( Aig_ManPiNum(p) );
-    Aig_ManForEachPo( p, pObj, i )
+    Aig_ManForEachCo( p, pObj, i )
     {
         vSup = Vec_VecEntryInt( vSupps, i );
         Vec_IntForEachEntry( vSup, Entry, k )
@@ -90,7 +90,7 @@ clk = clock();
     vOverNew  = Vec_IntAlloc( Aig_ManPoNum(p) );
     vQuantNew = Vec_IntAlloc( Aig_ManPoNum(p) );
 //    pProgress = Bar_ProgressStart( stdout, Aig_ManPoNum(p) );
-    Aig_ManForEachPo( p, pObj, i )
+    Aig_ManForEachCo( p, pObj, i )
     {
 //        Bar_ProgressUpdate( pProgress, i, NULL );
         // get old supports
@@ -101,7 +101,7 @@ clk = clock();
         CountOver = CountQuant = 0;
         vSupNew = Vec_IntDup( vSup );
         // go through the nodes where the first var appears
-        Aig_ManForEachPo( p, pObj, k )
+        Aig_ManForEachCo( p, pObj, k )
 //        iVar = Vec_IntEntry( vSup, 0 );
 //        vSupIn = Vec_VecEntry( vSuppsIn, iVar );
 //        Vec_IntForEachEntry( vSupIn, Entry, k )
@@ -198,7 +198,7 @@ clk = clock();
     vSupps = (Vec_Vec_t *)Aig_ManSupports( p );
 ABC_PRT( "Supports", clock() - clk );
     // remove last entry
-    Aig_ManForEachPo( p, pObj, i )
+    Aig_ManForEachCo( p, pObj, i )
     {
         vSup = Vec_VecEntryInt( vSupps, i );
         Vec_IntPop( vSup );
@@ -209,7 +209,7 @@ ABC_PRT( "Supports", clock() - clk );
     // create reverse supports
 clk = clock();
     vSuppsIn = Vec_VecStart( Aig_ManPiNum(p) );
-    Aig_ManForEachPo( p, pObj, i )
+    Aig_ManForEachCo( p, pObj, i )
     {
         if ( i == p->nAsserts )
             break;
@@ -222,7 +222,7 @@ ABC_PRT( "Inverse ", clock() - clk );
     // create affective supports
 clk = clock();
     pSupp = ABC_ALLOC( char, Aig_ManPiNum(p) );
-    Aig_ManForEachPo( p, pObj, i )
+    Aig_ManForEachCo( p, pObj, i )
     {
         if ( i % 50 != 0 )
             continue;
diff --git a/src/proof/fra/fraSim.c b/src/proof/fra/fraSim.c
index eb42c665..e54846bc 100644
--- a/src/proof/fra/fraSim.c
+++ b/src/proof/fra/fraSim.c
@@ -243,7 +243,7 @@ void Fra_SmlSavePattern( Fra_Man_t * p )
     Aig_Obj_t * pObj;
     int i;
     memset( p->pPatWords, 0, sizeof(unsigned) * p->nPatWords );
-    Aig_ManForEachPi( p->pManFraig, pObj, i )
+    Aig_ManForEachCi( p->pManFraig, pObj, i )
 //        if ( p->pSat->model.ptr[Fra_ObjSatNum(pObj)] == l_True )
         if ( sat_solver_var_value(p->pSat, Fra_ObjSatNum(pObj)) )
             Abc_InfoSetBit( p->pPatWords, i );
@@ -259,7 +259,7 @@ void Fra_SmlSavePattern( Fra_Man_t * p )
 
 /*
     printf( "Pattern: " );
-    Aig_ManForEachPi( p->pManFraig, pObj, i )
+    Aig_ManForEachCi( p->pManFraig, pObj, i )
         printf( "%d", Abc_InfoHasBit( p->pPatWords, i ) );
     printf( "\n" );
 */
@@ -299,7 +299,7 @@ void Fra_SmlCheckOutputSavePattern( Fra_Man_t * p, Aig_Obj_t * pObjPo )
     BestPat = i * 32 + k;
     // fill in the counter-example data
     pModel = ABC_ALLOC( int, Aig_ManPiNum(p->pManFraig)+1 );
-    Aig_ManForEachPi( p->pManAig, pObjPi, i )
+    Aig_ManForEachCi( p->pManAig, pObjPi, i )
     {
         pModel[i] = Abc_InfoHasBit(Fra_ObjSim(p->pSml, pObjPi->Id), BestPat);
 //        printf( "%d", pModel[i] );
@@ -330,7 +330,7 @@ int Fra_SmlCheckOutput( Fra_Man_t * p )
     // make sure the reference simulation pattern does not detect the bug
     pObj = Aig_ManPo( p->pManAig, 0 );
     assert( Aig_ObjFanin0(pObj)->fPhase == (unsigned)Aig_ObjFaninC0(pObj) ); 
-    Aig_ManForEachPo( p->pManAig, pObj, i )
+    Aig_ManForEachCo( p->pManAig, pObj, i )
     {
         if ( !Fra_SmlNodeIsConst( Aig_ObjFanin0(pObj) ) )
         {
@@ -414,7 +414,7 @@ void Fra_SmlInitialize( Fra_Sml_t * p, int fInit )
     }
     else
     {
-        Aig_ManForEachPi( p->pAig, pObj, i )
+        Aig_ManForEachCi( p->pAig, pObj, i )
             Fra_SmlAssignRandom( p, pObj );
     }
 }
@@ -438,7 +438,7 @@ void Fra_SmlAssignDist1( Fra_Sml_t * p, unsigned * pPat )
     if ( p->nFrames == 1 )
     {
         // copy the PI info 
-        Aig_ManForEachPi( p->pAig, pObj, i )
+        Aig_ManForEachCi( p->pAig, pObj, i )
             Fra_SmlAssignConst( p, pObj, Abc_InfoHasBit(pPat, i), 0 );
         // flip one bit
         Limit = Abc_MinInt( Aig_ManPiNum(p->pAig), p->nWordsTotal * 32 - 1 );
@@ -980,7 +980,7 @@ Abc_Cex_t * Fra_SmlCopyCounterExample( Aig_Man_t * pAig, Aig_Man_t * pFrames, in
     // find the PO that failed
     iPo = -1;
     iFrame = -1;
-    Aig_ManForEachPo( pFrames, pObj, i )
+    Aig_ManForEachCo( pFrames, pObj, i )
         if ( pObj->Id == pModel[Aig_ManPiNum(pFrames)] )
         {
             iPo = i % nTruePos;