initial commit of public abc

14 files changed, 128 insertions, 60 deletions

diff --git a/src/opt/lpk/lpk.h b/src/opt/lpk/lpk.h
index d7e4af29..498da845 100644
--- a/src/opt/lpk/lpk.h
+++ b/src/opt/lpk/lpk.h
@@ -21,6 +21,7 @@
 #ifndef __LPK_H__
 #define __LPK_H__
 
+
 ////////////////////////////////////////////////////////////////////////
 ///                          INCLUDES                                ///
 ////////////////////////////////////////////////////////////////////////
@@ -29,9 +30,10 @@
 ///                         PARAMETERS                               ///
 ////////////////////////////////////////////////////////////////////////
 
-#ifdef __cplusplus
-extern "C" {
-#endif 
+
+
+ABC_NAMESPACE_HEADER_START
+ 
 
 ////////////////////////////////////////////////////////////////////////
 ///                         BASIC TYPES                              ///
@@ -72,9 +74,11 @@ struct Lpk_Par_t_
 extern int     Lpk_Resynthesize( Abc_Ntk_t * pNtk, Lpk_Par_t * pPars );
 
 
-#ifdef __cplusplus
-}
-#endif
+
+
+ABC_NAMESPACE_HEADER_END
+
+
 
 #endif
 
diff --git a/src/opt/lpk/lpkAbcDec.c b/src/opt/lpk/lpkAbcDec.c
index c06f0bf1..de5b66cc 100644
--- a/src/opt/lpk/lpkAbcDec.c
+++ b/src/opt/lpk/lpkAbcDec.c
@@ -20,6 +20,9 @@
  
 #include "lpkInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -52,22 +55,22 @@ Abc_Obj_t * Lpk_ImplementFun( Lpk_Man_t * pMan, Abc_Ntk_t * pNtk, Vec_Ptr_t * vL
     // create the new node
     pObjNew = Abc_NtkCreateNode( pNtk );
     for ( i = 0; i < (int)p->nVars; i++ )
-        Abc_ObjAddFanin( pObjNew, Abc_ObjRegular(Vec_PtrEntry(vLeaves, p->pFanins[i])) );
+        Abc_ObjAddFanin( pObjNew, Abc_ObjRegular((Abc_Obj_t *)Vec_PtrEntry(vLeaves, p->pFanins[i])) );
     Abc_ObjSetLevel( pObjNew, Abc_ObjLevelNew(pObjNew) );
     // assign the node's function
     pTruth = Lpk_FunTruth(p, 0);
     if ( p->nVars == 0 )
     {
-        pObjNew->pData = Hop_NotCond( Hop_ManConst1(pNtk->pManFunc), !(pTruth[0] & 1) );
+        pObjNew->pData = Hop_NotCond( Hop_ManConst1((Hop_Man_t *)pNtk->pManFunc), !(pTruth[0] & 1) );
         return pObjNew;
     }
     if ( p->nVars == 1 )
     {
-        pObjNew->pData = Hop_NotCond( Hop_ManPi(pNtk->pManFunc, 0), (pTruth[0] & 1) );
+        pObjNew->pData = Hop_NotCond( Hop_ManPi((Hop_Man_t *)pNtk->pManFunc, 0), (pTruth[0] & 1) );
         return pObjNew;
     }
     // create the logic function
-    pObjNew->pData = Kit_TruthToHop( pNtk->pManFunc, pTruth, p->nVars, NULL );
+    pObjNew->pData = Kit_TruthToHop( (Hop_Man_t *)pNtk->pManFunc, pTruth, p->nVars, NULL );
     return pObjNew;
 }
 
@@ -89,10 +92,10 @@ Abc_Obj_t * Lpk_Implement_rec( Lpk_Man_t * pMan, Abc_Ntk_t * pNtk, Vec_Ptr_t * v
     // prepare the leaves of the function
     for ( i = 0; i < (int)pFun->nVars; i++ )
     {
-        pFanin = Vec_PtrEntry( vLeaves, pFun->pFanins[i] );
+        pFanin = (Abc_Obj_t *)Vec_PtrEntry( vLeaves, pFun->pFanins[i] );
         if ( !Abc_ObjIsComplement(pFanin) )
             Lpk_Implement_rec( pMan, pNtk, vLeaves, (Lpk_Fun_t *)pFanin );
-        pFanin = Vec_PtrEntry( vLeaves, pFun->pFanins[i] );
+        pFanin = (Abc_Obj_t *)Vec_PtrEntry( vLeaves, pFun->pFanins[i] );
         assert( Abc_ObjIsComplement(pFanin) );
     }
     // construct the function
@@ -120,10 +123,10 @@ Abc_Obj_t * Lpk_Implement( Lpk_Man_t * pMan, Abc_Ntk_t * pNtk, Vec_Ptr_t * vLeav
     int i;
     assert( nLeavesOld < Vec_PtrSize(vLeaves) );
     // mark implemented nodes
-    Vec_PtrForEachEntryStop( vLeaves, pFanin, i, nLeavesOld )
+    Vec_PtrForEachEntryStop( Abc_Obj_t *, vLeaves, pFanin, i, nLeavesOld )
         Vec_PtrWriteEntry( vLeaves, i, Abc_ObjNot(pFanin) );
     // recursively construct starting from the first entry
-    pRes = Lpk_Implement_rec( pMan, pNtk, vLeaves, Vec_PtrEntry( vLeaves, nLeavesOld ) );
+    pRes = Lpk_Implement_rec( pMan, pNtk, vLeaves, (Lpk_Fun_t *)Vec_PtrEntry( vLeaves, nLeavesOld ) );
     Vec_PtrShrink( vLeaves, nLeavesOld );
     return pRes;
 }
@@ -236,7 +239,7 @@ void Lpk_DecomposeClean( Vec_Ptr_t * vLeaves, int nLeavesOld )
 {
     Lpk_Fun_t * pFunc;
     int i;
-    Vec_PtrForEachEntryStart( vLeaves, pFunc, i, nLeavesOld )
+    Vec_PtrForEachEntryStart( Lpk_Fun_t *, vLeaves, pFunc, i, nLeavesOld )
         Lpk_FunFree( pFunc );
     Vec_PtrShrink( vLeaves, nLeavesOld );
 }
@@ -287,3 +290,5 @@ Abc_Obj_t * Lpk_Decompose( Lpk_Man_t * p, Abc_Ntk_t * pNtk, Vec_Ptr_t * vLeaves,
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/lpk/lpkAbcDsd.c b/src/opt/lpk/lpkAbcDsd.c
index a1cd9def..34785941 100644
--- a/src/opt/lpk/lpkAbcDsd.c
+++ b/src/opt/lpk/lpkAbcDsd.c
@@ -20,6 +20,9 @@
 
 #include "lpkInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -610,3 +613,5 @@ Lpk_Fun_t * Lpk_DsdSplit( Lpk_Man_t * pMan, Lpk_Fun_t * p, char * pCofVars, int
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/lpk/lpkAbcMux.c b/src/opt/lpk/lpkAbcMux.c
index d6f579ee..4e9cc654 100644
--- a/src/opt/lpk/lpkAbcMux.c
+++ b/src/opt/lpk/lpkAbcMux.c
@@ -20,6 +20,9 @@
 
 #include "lpkInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -233,3 +236,5 @@ Extra_PrintBinary( stdout, &uSupp, 16 ); printf( "\n\n" );
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/lpk/lpkAbcUtil.c b/src/opt/lpk/lpkAbcUtil.c
index ae295624..b086d35f 100644
--- a/src/opt/lpk/lpkAbcUtil.c
+++ b/src/opt/lpk/lpkAbcUtil.c
@@ -20,6 +20,9 @@
 
 #include "lpkInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -88,7 +91,7 @@ Lpk_Fun_t * Lpk_FunCreate( Abc_Ntk_t * pNtk, Vec_Ptr_t * vLeaves, unsigned * pTr
     p->nDelayLim = DelayLim;
     p->uSupp = Kit_TruthSupport( pTruth, p->nVars );
     Kit_TruthCopy( Lpk_FunTruth(p,0), pTruth, p->nVars );
-    Vec_PtrForEachEntry( vLeaves, pNode, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vLeaves, pNode, i )
     {
         p->pFanins[i] = i;
         p->pDelays[i] = pNode->Level;
@@ -242,3 +245,5 @@ int Lpk_SuppToVars( unsigned uBoundSet, char * pVars )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/lpk/lpkCore.c b/src/opt/lpk/lpkCore.c
index 7cc4b154..d3a6ba67 100644
--- a/src/opt/lpk/lpkCore.c
+++ b/src/opt/lpk/lpkCore.c
@@ -21,6 +21,9 @@
 #include "lpkInt.h"
 #include "cloud.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -94,10 +97,10 @@ int Lpk_NodeHasChanged( Lpk_Man_t * p, int iNode )
     Vec_Ptr_t * vNodes;
     Abc_Obj_t * pTemp;
     int i;
-    vNodes = Vec_VecEntry( p->vVisited, iNode );
+    vNodes = (Vec_Ptr_t *)Vec_VecEntry( p->vVisited, iNode );
     if ( Vec_PtrSize(vNodes) == 0 )
         return 1;
-    Vec_PtrForEachEntry( vNodes, pTemp, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pTemp, i )
     {
         // check if the node has changed
         pTemp = Abc_NtkObj( p->pNtk, (int)(ABC_PTRUINT_T)pTemp );
@@ -213,7 +216,7 @@ p->timeMap += clock() - clk;
         If_ObjSetCopy( If_ManCi(p->pIfMan, i), pLeaf );
     // get the area of mapping
     pObjNew = Abc_NodeFromIf_rec( p->pNtk, p->pIfMan, If_Regular(pDriver), p->vCover );
-    pObjNew->pData = Hop_NotCond( pObjNew->pData, If_IsComplement(pDriver) );
+    pObjNew->pData = Hop_NotCond( (Hop_Obj_t *)pObjNew->pData, If_IsComplement(pDriver) );
     // perform replacement
     Abc_NtkUpdate( p->pObj, pObjNew, p->vLevels );
 //printf( "%3d : %d-%d=%d(%d) \n", p->nChanges, nNodesBef, Abc_NtkNodeNum(p->pNtk), nNodesBef-Abc_NtkNodeNum(p->pNtk), nGain );
@@ -444,7 +447,7 @@ p->timeTruth3 += clock() - clk;
             int nSuppSize = Extra_TruthSupportSize( pTruth, pCut->nLeaves );
             printf( "  C%02d: L= %2d/%2d  V= %2d/%d  N= %d  W= %4.2f  ", 
                 i, pCut->nLeaves, nSuppSize, pCut->nNodes, pCut->nNodesDup, pCut->nLuts, pCut->Weight );
-            Vec_PtrForEachEntry( p->vLeaves, pLeaf, k )
+            Vec_PtrForEachEntry( Abc_Obj_t *, p->vLeaves, pLeaf, k )
                 printf( "%c=%d ", 'a'+k, Abc_ObjLevel(pLeaf) );
             printf( "\n" );
             Kit_DsdPrintFromTruth( pTruth, pCut->nLeaves );
@@ -683,3 +686,5 @@ int Lpk_Resynthesize( Abc_Ntk_t * pNtk, Lpk_Par_t * pPars )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/lpk/lpkCut.c b/src/opt/lpk/lpkCut.c
index 6f0eed84..ac0a3516 100644
--- a/src/opt/lpk/lpkCut.c
+++ b/src/opt/lpk/lpkCut.c
@@ -21,6 +21,9 @@
 #include "lpkInt.h"
 #include "cloud.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -47,7 +50,7 @@ CloudNode * Lpk_CutTruthBdd_rec( CloudManager * dd, Hop_Man_t * pMan, Hop_Obj_t
     if ( pObj->pData )
     {
         assert( ((unsigned)(ABC_PTRUINT_T)pObj->pData) & 0xffff0000 );
-        return pObj->pData;
+        return (CloudNode *)pObj->pData;
     }
     // get the plan for a new truth table
     if ( Hop_ObjIsConst1(pObj) )
@@ -81,7 +84,7 @@ CloudNode * Lpk_CutTruthBdd_rec( CloudManager * dd, Hop_Man_t * pMan, Hop_Obj_t
 CloudNode * Lpk_CutTruthBdd( Lpk_Man_t * p, Lpk_Cut_t * pCut )
 {
     CloudManager * dd = p->pDsdMan->dd;
-    Hop_Man_t * pManHop = p->pNtk->pManFunc;
+    Hop_Man_t * pManHop = (Hop_Man_t *)p->pNtk->pManFunc;
     Hop_Obj_t * pObjHop;
     Abc_Obj_t * pObj, * pFanin;
     CloudNode * pTruth = NULL; // Suppress "might be used uninitialized"
@@ -97,7 +100,7 @@ CloudNode * Lpk_CutTruthBdd( Lpk_Man_t * p, Lpk_Cut_t * pCut )
     Lpk_CutForEachNodeReverse( p->pNtk, pCut, pObj, i )
     {
         // get the local AIG
-        pObjHop = Hop_Regular(pObj->pData);
+        pObjHop = Hop_Regular((Hop_Obj_t *)pObj->pData);
         // clean the data field of the nodes in the AIG subgraph
         Hop_ObjCleanData_rec( pObjHop );
         // set the initial truth tables at the fanins
@@ -108,7 +111,7 @@ CloudNode * Lpk_CutTruthBdd( Lpk_Man_t * p, Lpk_Cut_t * pCut )
         }
         // compute the truth table of internal nodes
         pTruth = Lpk_CutTruthBdd_rec( dd, pManHop, pObjHop, pCut->nLeaves );
-        if ( Hop_IsComplement(pObj->pData) )
+        if ( Hop_IsComplement((Hop_Obj_t *)pObj->pData) )
             pTruth = Cloud_Not(pTruth);
         // set the truth table at the node
         pObj->pCopy = (Abc_Obj_t *)pTruth;
@@ -139,10 +142,10 @@ unsigned * Lpk_CutTruth_rec( Hop_Man_t * pMan, Hop_Obj_t * pObj, int nVars, Vec_
     if ( pObj->pData )
     {
         assert( ((unsigned)(ABC_PTRUINT_T)pObj->pData) & 0xffff0000 );
-        return pObj->pData;
+        return (unsigned *)pObj->pData;
     }
     // get the plan for a new truth table
-    pTruth = Vec_PtrEntry( vTtNodes, (*piCount)++ );
+    pTruth = (unsigned *)Vec_PtrEntry( vTtNodes, (*piCount)++ );
     if ( Hop_ObjIsConst1(pObj) )
         Kit_TruthFill( pTruth, nVars );
     else
@@ -171,7 +174,7 @@ unsigned * Lpk_CutTruth_rec( Hop_Man_t * pMan, Hop_Obj_t * pObj, int nVars, Vec_
 ***********************************************************************/
 unsigned * Lpk_CutTruth( Lpk_Man_t * p, Lpk_Cut_t * pCut, int fInv )
 {
-    Hop_Man_t * pManHop = p->pNtk->pManFunc;
+    Hop_Man_t * pManHop = (Hop_Man_t *)p->pNtk->pManFunc;
     Hop_Obj_t * pObjHop;
     Abc_Obj_t * pObj = NULL; // Suppress "might be used uninitialized"
     Abc_Obj_t * pFanin;
@@ -182,13 +185,13 @@ unsigned * Lpk_CutTruth( Lpk_Man_t * p, Lpk_Cut_t * pCut, int fInv )
 
     // initialize the leaves
     Lpk_CutForEachLeaf( p->pNtk, pCut, pObj, i )
-        pObj->pCopy = Vec_PtrEntry( p->vTtElems, fInv? pCut->nLeaves-1-i : i );
+        pObj->pCopy = (Abc_Obj_t *)Vec_PtrEntry( p->vTtElems, fInv? pCut->nLeaves-1-i : i );
 
     // construct truth table in the topological order
     Lpk_CutForEachNodeReverse( p->pNtk, pCut, pObj, i )
     {
         // get the local AIG
-        pObjHop = Hop_Regular(pObj->pData);
+        pObjHop = Hop_Regular((Hop_Obj_t *)pObj->pData);
         // clean the data field of the nodes in the AIG subgraph
         Hop_ObjCleanData_rec( pObjHop );
         // set the initial truth tables at the fanins
@@ -199,7 +202,7 @@ unsigned * Lpk_CutTruth( Lpk_Man_t * p, Lpk_Cut_t * pCut, int fInv )
         }
         // compute the truth table of internal nodes
         pTruth = Lpk_CutTruth_rec( pManHop, pObjHop, pCut->nLeaves, p->vTtNodes, &iCount );
-        if ( Hop_IsComplement(pObj->pData) )
+        if ( Hop_IsComplement((Hop_Obj_t *)pObj->pData) )
             Kit_TruthNot( pTruth, pTruth, pCut->nLeaves );
         // set the truth table at the node
         pObj->pCopy = (Abc_Obj_t *)pTruth;
@@ -208,7 +211,7 @@ unsigned * Lpk_CutTruth( Lpk_Man_t * p, Lpk_Cut_t * pCut, int fInv )
     // make sure direct truth table is stored elsewhere (assuming the first call for direct truth!!!)
     if ( fInv == 0 )
     {
-        pTruth = Vec_PtrEntry( p->vTtNodes, iCount++ );
+        pTruth = (unsigned *)Vec_PtrEntry( p->vTtNodes, iCount++ );
         Kit_TruthCopy( pTruth, (unsigned *)(ABC_PTRUINT_T)pObj->pCopy, pCut->nLeaves );
     }
     assert( iCount <= Vec_PtrSize(p->vTtNodes) );
@@ -230,7 +233,7 @@ unsigned * Lpk_CutTruth( Lpk_Man_t * p, Lpk_Cut_t * pCut, int fInv )
 void Lpk_NodeRecordImpact( Lpk_Man_t * p )
 {
     Lpk_Cut_t * pCut;
-    Vec_Ptr_t * vNodes = Vec_VecEntry( p->vVisited, p->pObj->Id );
+    Vec_Ptr_t * vNodes = (Vec_Ptr_t *)Vec_VecEntry( p->vVisited, p->pObj->Id );
     Abc_Obj_t * pNode;
     int i, k;
     // collect the nodes that impact the given node
@@ -249,7 +252,7 @@ void Lpk_NodeRecordImpact( Lpk_Man_t * p )
         }
     }
     // clear the marks
-    Vec_PtrForEachEntry( vNodes, pNode, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pNode, i )
     {
         pNode = Abc_NtkObj( p->pNtk, (int)(ABC_PTRUINT_T)pNode );
         pNode->fMarkC = 0;
@@ -281,7 +284,7 @@ int Lpk_NodeCutsCheckDsd( Lpk_Man_t * p, Lpk_Cut_t * pCut )
     {
         assert( pObj->fMarkA == 0 );
         pObj->fMarkA = 1;
-        pObj->pCopy = (void *)(ABC_PTRUINT_T)i;
+        pObj->pCopy = (Abc_Obj_t *)(ABC_PTRUINT_T)i;
     }
     // ref leaves pointed from the internal nodes
     nCands = 0;
@@ -682,3 +685,5 @@ int Lpk_NodeCuts( Lpk_Man_t * p )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/lpk/lpkInt.h b/src/opt/lpk/lpkInt.h
index 26bb846a..5cb8c1a2 100644
--- a/src/opt/lpk/lpkInt.h
+++ b/src/opt/lpk/lpkInt.h
@@ -21,6 +21,7 @@
 #ifndef __LPK_INT_H__
 #define __LPK_INT_H__
 
+
 ////////////////////////////////////////////////////////////////////////
 ///                          INCLUDES                                ///
 ////////////////////////////////////////////////////////////////////////
@@ -34,9 +35,10 @@
 ///                         PARAMETERS                               ///
 ////////////////////////////////////////////////////////////////////////
 
-#ifdef __cplusplus
-extern "C" {
-#endif 
+
+
+ABC_NAMESPACE_HEADER_START
+ 
 
 ////////////////////////////////////////////////////////////////////////
 ///                         BASIC TYPES                              ///
@@ -234,9 +236,11 @@ extern If_Obj_t *     Lpk_MapSuppRedDec_rec( Lpk_Man_t * p, unsigned * pTruth, i
 /*=== lpkSets.c =========================================================*/
 extern unsigned       Lpk_MapSuppRedDecSelect( Lpk_Man_t * p, unsigned * pTruth, int nVars, int * piVar, int * piVarReused );
 
-#ifdef __cplusplus
-}
-#endif
+
+
+ABC_NAMESPACE_HEADER_END
+
+
 
 #endif
 
diff --git a/src/opt/lpk/lpkMan.c b/src/opt/lpk/lpkMan.c
index 024f724a..f012ab75 100644
--- a/src/opt/lpk/lpkMan.c
+++ b/src/opt/lpk/lpkMan.c
@@ -20,6 +20,9 @@
 
 #include "lpkInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -120,3 +123,5 @@ void Lpk_ManStop( Lpk_Man_t * p )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/lpk/lpkMap.c b/src/opt/lpk/lpkMap.c
index f959f8f9..c6c6b233 100644
--- a/src/opt/lpk/lpkMap.c
+++ b/src/opt/lpk/lpkMap.c
@@ -20,6 +20,9 @@
 
 #include "lpkInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -49,17 +52,17 @@ If_Obj_t * Lpk_MapPrimeInternal( If_Man_t * pIfMan, Kit_Graph_t * pGraph )
         return If_ManConst1(pIfMan);
     // check for a literal
     if ( Kit_GraphIsVar(pGraph) )
-        return Kit_GraphVar(pGraph)->pFunc;
+        return (If_Obj_t *)Kit_GraphVar(pGraph)->pFunc;
     // build the AIG nodes corresponding to the AND gates of the graph
     Kit_GraphForEachNode( pGraph, pNode, i )
     {
-        pAnd0 = Kit_GraphNode(pGraph, pNode->eEdge0.Node)->pFunc; 
-        pAnd1 = Kit_GraphNode(pGraph, pNode->eEdge1.Node)->pFunc; 
+        pAnd0 = (If_Obj_t *)Kit_GraphNode(pGraph, pNode->eEdge0.Node)->pFunc; 
+        pAnd1 = (If_Obj_t *)Kit_GraphNode(pGraph, pNode->eEdge1.Node)->pFunc; 
         pNode->pFunc = If_ManCreateAnd( pIfMan, 
             If_NotCond( If_Regular(pAnd0), If_IsComplement(pAnd0) ^ pNode->eEdge0.fCompl ), 
             If_NotCond( If_Regular(pAnd1), If_IsComplement(pAnd1) ^ pNode->eEdge1.fCompl ) );
     }
-    return pNode->pFunc;
+    return (If_Obj_t *)pNode->pFunc;
 }
 
 /**Function*************************************************************
@@ -203,3 +206,5 @@ If_Obj_t * Lpk_MapTree_rec( Lpk_Man_t * p, Kit_DsdNtk_t * pNtk, If_Obj_t ** ppLe
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/lpk/lpkMulti.c b/src/opt/lpk/lpkMulti.c
index d5f1fd11..cce154ee 100644
--- a/src/opt/lpk/lpkMulti.c
+++ b/src/opt/lpk/lpkMulti.c
@@ -20,6 +20,9 @@
 
 #include "lpkInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -506,3 +509,5 @@ If_Obj_t * Lpk_MapTreeMulti( Lpk_Man_t * p, unsigned * pTruth, int nVars, If_Obj
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/lpk/lpkMux.c b/src/opt/lpk/lpkMux.c
index ed046ad7..01c28c8c 100644
--- a/src/opt/lpk/lpkMux.c
+++ b/src/opt/lpk/lpkMux.c
@@ -20,6 +20,9 @@
 
 #include "lpkInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -85,8 +88,8 @@ int Lpk_MapTreeBestCofVar( Lpk_Man_t * p, unsigned * pTruth, int nVars, unsigned
 ***********************************************************************/
 If_Obj_t * Lpk_MapTreeMux_rec( Lpk_Man_t * p, unsigned * pTruth, int nVars, If_Obj_t ** ppLeaves )
 {
-    unsigned * pCof0 = Vec_PtrEntry( p->vTtNodes, 0 );
-    unsigned * pCof1 = Vec_PtrEntry( p->vTtNodes, 1 );
+    unsigned * pCof0 = (unsigned *)Vec_PtrEntry( p->vTtNodes, 0 );
+    unsigned * pCof1 = (unsigned *)Vec_PtrEntry( p->vTtNodes, 1 );
     If_Obj_t * pObj0, * pObj1;
     Kit_DsdNtk_t * ppNtks[2];
     int iBestVar;
@@ -131,18 +134,18 @@ If_Obj_t * Lpk_MapSuppRedDec_rec( Lpk_Man_t * p, unsigned * pTruth, int nVars, I
 {
     Kit_DsdNtk_t * pNtkDec, * pNtkComp, * ppNtks[2], * pTemp;
     If_Obj_t * pObjNew;
-    unsigned * pCof0 = Vec_PtrEntry( p->vTtNodes,  0 );
-    unsigned * pCof1 = Vec_PtrEntry( p->vTtNodes,  1 );
-    unsigned * pDec0 = Vec_PtrEntry( p->vTtNodes,  2 );
-    unsigned * pDec1 = Vec_PtrEntry( p->vTtNodes,  3 );
-    unsigned * pDec  = Vec_PtrEntry( p->vTtNodes,  4 );
-    unsigned * pCo00 = Vec_PtrEntry( p->vTtNodes,  5 );
-    unsigned * pCo01 = Vec_PtrEntry( p->vTtNodes,  6 );
-    unsigned * pCo10 = Vec_PtrEntry( p->vTtNodes,  7 );
-    unsigned * pCo11 = Vec_PtrEntry( p->vTtNodes,  8 );
-    unsigned * pCo0  = Vec_PtrEntry( p->vTtNodes,  9 );
-    unsigned * pCo1  = Vec_PtrEntry( p->vTtNodes, 10 );
-    unsigned * pCo   = Vec_PtrEntry( p->vTtNodes, 11 );
+    unsigned * pCof0 = (unsigned *)Vec_PtrEntry( p->vTtNodes,  0 );
+    unsigned * pCof1 = (unsigned *)Vec_PtrEntry( p->vTtNodes,  1 );
+    unsigned * pDec0 = (unsigned *)Vec_PtrEntry( p->vTtNodes,  2 );
+    unsigned * pDec1 = (unsigned *)Vec_PtrEntry( p->vTtNodes,  3 );
+    unsigned * pDec  = (unsigned *)Vec_PtrEntry( p->vTtNodes,  4 );
+    unsigned * pCo00 = (unsigned *)Vec_PtrEntry( p->vTtNodes,  5 );
+    unsigned * pCo01 = (unsigned *)Vec_PtrEntry( p->vTtNodes,  6 );
+    unsigned * pCo10 = (unsigned *)Vec_PtrEntry( p->vTtNodes,  7 );
+    unsigned * pCo11 = (unsigned *)Vec_PtrEntry( p->vTtNodes,  8 );
+    unsigned * pCo0  = (unsigned *)Vec_PtrEntry( p->vTtNodes,  9 );
+    unsigned * pCo1  = (unsigned *)Vec_PtrEntry( p->vTtNodes, 10 );
+    unsigned * pCo   = (unsigned *)Vec_PtrEntry( p->vTtNodes, 11 );
     int TrueMint0, TrueMint1, FalseMint0, FalseMint1;
     int uSubsets, uSubset0, uSubset1, iVar, iVarReused, i;
 
@@ -245,3 +248,5 @@ If_Obj_t * Lpk_MapSuppRedDec_rec( Lpk_Man_t * p, unsigned * pTruth, int nVars, I
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/lpk/lpkSets.c b/src/opt/lpk/lpkSets.c
index 90e46863..65b23ea9 100644
--- a/src/opt/lpk/lpkSets.c
+++ b/src/opt/lpk/lpkSets.c
@@ -20,6 +20,9 @@
 
 #include "lpkInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -324,8 +327,8 @@ unsigned Lpk_MapSuppRedDecSelect( Lpk_Man_t * p, unsigned * pTruth, int nVars, i
     Kit_DsdNtk_t * ppNtks[2], * pTemp;
     Vec_Int_t * vSets0 = p->vSets[0];
     Vec_Int_t * vSets1 = p->vSets[1];
-    unsigned * pCof0 = Vec_PtrEntry( p->vTtNodes, 0 );
-    unsigned * pCof1 = Vec_PtrEntry( p->vTtNodes, 1 );
+    unsigned * pCof0 = (unsigned *)Vec_PtrEntry( p->vTtNodes, 0 );
+    unsigned * pCof1 = (unsigned *)Vec_PtrEntry( p->vTtNodes, 1 );
     int nSets, i, SizeMax;//, SRedMax;
     unsigned Entry;
     int fVerbose = p->pPars->fVeryVerbose;
@@ -438,3 +441,5 @@ unsigned Lpk_MapSuppRedDecSelect( Lpk_Man_t * p, unsigned * pTruth, int nVars, i
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/lpk/lpk_.c b/src/opt/lpk/lpk_.c
index d8555e08..8b61babd 100644
--- a/src/opt/lpk/lpk_.c
+++ b/src/opt/lpk/lpk_.c
@@ -20,6 +20,9 @@
 
 #include "lpkInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -46,3 +49,5 @@
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+