initial commit of public abc

107 files changed, 1808 insertions, 974 deletions

diff --git a/src/opt/cut/abcCut.c b/src/opt/cut/abcCut.c
index 9bbd5790..3b80fe8d 100644
--- a/src/opt/cut/abcCut.c
+++ b/src/opt/cut/abcCut.c
@@ -21,6 +21,9 @@
 #include "abc.h"
 #include "cut.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -102,7 +105,7 @@ Cut_Man_t * Abc_NtkCuts( Abc_Ntk_t * pNtk, Cut_Params_t * pParams )
     vNodes = Abc_AigDfs( pNtk, 0, 1 ); // collects POs
     vChoices = Vec_IntAlloc( 100 );
     pProgress = Extra_ProgressBarStart( stdout, Vec_PtrSize(vNodes) );
-    Vec_PtrForEachEntry( vNodes, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
     {
         // when we reached a CO, it is time to deallocate the cuts
         if ( Abc_ObjIsCo(pObj) )
@@ -176,7 +179,7 @@ void Abc_NtkCutsOracle( Abc_Ntk_t * pNtk, Cut_Oracle_t * p )
 
     // compute cuts for internal nodes
     vNodes = Abc_AigDfs( pNtk, 0, 1 ); // collects POs
-    Vec_PtrForEachEntry( vNodes, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
     {
         // when we reached a CO, it is time to deallocate the cuts
         if ( Abc_ObjIsCo(pObj) )
@@ -490,3 +493,5 @@ void Abc_NtkPrintCuts_( void * p, Abc_Ntk_t * pNtk, int fSeq )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/cut/cut.h b/src/opt/cut/cut.h
index 394138db..6c497675 100644
--- a/src/opt/cut/cut.h
+++ b/src/opt/cut/cut.h
@@ -21,6 +21,7 @@
 #ifndef __CUT_H__
 #define __CUT_H__
 
+
 ////////////////////////////////////////////////////////////////////////
 ///                          INCLUDES                                ///
 ////////////////////////////////////////////////////////////////////////
@@ -29,9 +30,10 @@
 ///                         PARAMETERS                               ///
 ////////////////////////////////////////////////////////////////////////
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+
+
+ABC_NAMESPACE_HEADER_START
+
 
 #define CUT_SIZE_MIN    3      // the min K of the K-feasible cut computation
 #define CUT_SIZE_MAX   12      // the max K of the K-feasible cut computation
@@ -155,9 +157,11 @@ extern int              Cut_CellIsRunning();
 extern void             Cut_CellDumpToFile();
 extern int              Cut_CellTruthLookup( unsigned * pTruth, int nVars );
 
-#ifdef __cplusplus
-}
-#endif
+
+
+ABC_NAMESPACE_HEADER_END
+
+
 
 #endif
 
diff --git a/src/opt/cut/cutApi.c b/src/opt/cut/cutApi.c
index 980c6b12..1b20437d 100644
--- a/src/opt/cut/cutApi.c
+++ b/src/opt/cut/cutApi.c
@@ -20,6 +20,9 @@
 
 #include "cutInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -43,7 +46,7 @@ Cut_Cut_t * Cut_NodeReadCutsNew( Cut_Man_t * p, int Node )
 {
     if ( Node >= p->vCutsNew->nSize )
         return NULL;
-    return Vec_PtrEntry( p->vCutsNew, Node );
+    return (Cut_Cut_t *)Vec_PtrEntry( p->vCutsNew, Node );
 }
 
 /**Function*************************************************************
@@ -60,7 +63,7 @@ Cut_Cut_t * Cut_NodeReadCutsNew( Cut_Man_t * p, int Node )
 Cut_Cut_t * Cut_NodeReadCutsOld( Cut_Man_t * p, int Node )
 {
     assert( Node < p->vCutsOld->nSize );
-    return Vec_PtrEntry( p->vCutsOld, Node );
+    return (Cut_Cut_t *)Vec_PtrEntry( p->vCutsOld, Node );
 }
 
 /**Function*************************************************************
@@ -77,7 +80,7 @@ Cut_Cut_t * Cut_NodeReadCutsOld( Cut_Man_t * p, int Node )
 Cut_Cut_t * Cut_NodeReadCutsTemp( Cut_Man_t * p, int Node )
 {
     assert( Node < p->vCutsTemp->nSize );
-    return Vec_PtrEntry( p->vCutsTemp, Node );
+    return (Cut_Cut_t *)Vec_PtrEntry( p->vCutsTemp, Node );
 }
 
 /**Function*************************************************************
@@ -195,3 +198,5 @@ void Cut_NodeFreeCuts( Cut_Man_t * p, int Node )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/cut/cutCut.c b/src/opt/cut/cutCut.c
index 94147278..bd0a70b1 100644
--- a/src/opt/cut/cutCut.c
+++ b/src/opt/cut/cutCut.c
@@ -20,6 +20,9 @@
 
 #include "cutInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -357,3 +360,5 @@ void Cut_CutPrintMerge( Cut_Cut_t * pCut, Cut_Cut_t * pCut0, Cut_Cut_t * pCut1 )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/cut/cutExpand.c b/src/opt/cut/cutExpand.c
index d389ef7a..4885f879 100644
--- a/src/opt/cut/cutExpand.c
+++ b/src/opt/cut/cutExpand.c
@@ -20,6 +20,9 @@
 
 #include "cutInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -182,3 +185,5 @@ void Cut_TruthCompose( Cut_Cut_t * pCutF, int Node, Cut_Cut_t * pCutT, Cut_Cut_t
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/cut/cutInt.h b/src/opt/cut/cutInt.h
index 17f268c7..4705c019 100644
--- a/src/opt/cut/cutInt.h
+++ b/src/opt/cut/cutInt.h
@@ -21,6 +21,7 @@
 #ifndef __CUT_INT_H__
 #define __CUT_INT_H__
 
+
 ////////////////////////////////////////////////////////////////////////
 ///                          INCLUDES                                ///
 ////////////////////////////////////////////////////////////////////////
@@ -31,6 +32,9 @@
 #include "cut.h"
 #include "cutList.h"
 
+ABC_NAMESPACE_HEADER_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                         PARAMETERS                               ///
 ////////////////////////////////////////////////////////////////////////
@@ -149,6 +153,10 @@ extern int                 Cut_TableReadTime( Cut_HashTable_t * pTable );
 extern void                Cut_TruthComputeOld( Cut_Cut_t * pCut, Cut_Cut_t * pCut0, Cut_Cut_t * pCut1, int fCompl0, int fCompl1 );
 extern void                Cut_TruthCompute( Cut_Man_t * p, Cut_Cut_t * pCut, Cut_Cut_t * pCut0, Cut_Cut_t * pCut1, int fCompl0, int fCompl1 );
 
+
+
+ABC_NAMESPACE_HEADER_END
+
 #endif
 
 ////////////////////////////////////////////////////////////////////////
diff --git a/src/opt/cut/cutList.h b/src/opt/cut/cutList.h
index a03ec9d5..0f0ccedf 100644
--- a/src/opt/cut/cutList.h
+++ b/src/opt/cut/cutList.h
@@ -21,6 +21,10 @@
 #ifndef __CUT_LIST_H__
 #define __CUT_LIST_H__
 
+
+ABC_NAMESPACE_HEADER_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                          INCLUDES                                ///
 ////////////////////////////////////////////////////////////////////////
@@ -199,6 +203,10 @@ static inline Cut_Cut_t * Cut_ListFinish( Cut_List_t * p )
     return pHead;
 }
 
+
+
+ABC_NAMESPACE_HEADER_END
+
 #endif
 
 ////////////////////////////////////////////////////////////////////////
diff --git a/src/opt/cut/cutMan.c b/src/opt/cut/cutMan.c
index 28264e33..4a9f8f4b 100644
--- a/src/opt/cut/cutMan.c
+++ b/src/opt/cut/cutMan.c
@@ -20,6 +20,9 @@
 
 #include "cutInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -313,3 +316,5 @@ void Cut_ManIncrementDagNodes( Cut_Man_t * p )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/cut/cutMerge.c b/src/opt/cut/cutMerge.c
index d8a9989c..66c8cadd 100644
--- a/src/opt/cut/cutMerge.c
+++ b/src/opt/cut/cutMerge.c
@@ -20,6 +20,9 @@
 
 #include "cutInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -655,3 +658,5 @@ Cut_Cut_t * Cut_CutMergeTwo5( Cut_Man_t * p, Cut_Cut_t * pCut0, Cut_Cut_t * pCut
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/cut/cutNode.c b/src/opt/cut/cutNode.c
index 633219fd..010e1e00 100644
--- a/src/opt/cut/cutNode.c
+++ b/src/opt/cut/cutNode.c
@@ -20,6 +20,9 @@
 
 #include "cutInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -490,20 +493,20 @@ int Cut_NodeMapping( Cut_Man_t * p, Cut_Cut_t * pCuts, int Node, int Node0, int
     // get the fanin cuts
     Delay0 = Vec_IntEntry( p->vDelays2, Node0 );
     Delay1 = Vec_IntEntry( p->vDelays2, Node1 );
-    pCut0 = (Delay0 == 0) ? Vec_PtrEntry( p->vCutsNew, Node0 ) : Vec_PtrEntry( p->vCutsMax, Node0 );
-    pCut1 = (Delay1 == 0) ? Vec_PtrEntry( p->vCutsNew, Node1 ) : Vec_PtrEntry( p->vCutsMax, Node1 );
+    pCut0 = (Delay0 == 0) ? (Cut_Cut_t *)Vec_PtrEntry( p->vCutsNew, Node0 ) : (Cut_Cut_t *)Vec_PtrEntry( p->vCutsMax, Node0 );
+    pCut1 = (Delay1 == 0) ? (Cut_Cut_t *)Vec_PtrEntry( p->vCutsNew, Node1 ) : (Cut_Cut_t *)Vec_PtrEntry( p->vCutsMax, Node1 );
     if ( Delay0 == Delay1 )
         Delay = (Delay0 == 0) ? Delay0 + 1: Delay0;
     else if ( Delay0 > Delay1 )
     {
         Delay = Delay0;
-        pCut1 = Vec_PtrEntry( p->vCutsNew, Node1 );
+        pCut1 = (Cut_Cut_t *)Vec_PtrEntry( p->vCutsNew, Node1 );
         assert( pCut1->nLeaves == 1 );
     }
     else // if ( Delay0 < Delay1 )
     {
         Delay = Delay1;
-        pCut0 = Vec_PtrEntry( p->vCutsNew, Node0 );
+        pCut0 = (Cut_Cut_t *)Vec_PtrEntry( p->vCutsNew, Node0 );
         assert( pCut0->nLeaves == 1 );
     }
     // merge the cuts
@@ -544,7 +547,7 @@ int Cut_ManMappingArea_rec( Cut_Man_t * p, int Node )
     int i, Counter;
     if ( p->vCutsMax == NULL )
         return 0;
-    pCut = Vec_PtrEntry( p->vCutsMax, Node );
+    pCut = (Cut_Cut_t *)Vec_PtrEntry( p->vCutsMax, Node );
     if ( pCut == NULL || pCut->nLeaves == 1 )
         return 0;
     Counter = 0;
@@ -729,7 +732,7 @@ Cut_Cut_t * Cut_NodeUnionCuts( Cut_Man_t * p, Vec_Int_t * vNodes )
                 Vec_IntForEachEntryStart( vNodes, Node, k, i+1 )
                     Cut_NodeFreeCuts( p, Node );
                 // recycle the saved cuts of other nodes
-                Vec_PtrForEachEntry( p->vTemp, pList, k )
+                Vec_PtrForEachEntry( Cut_Cut_t *, p->vTemp, pList, k )
                     Cut_ListForEachCutSafe( pList, pCut, pCut2 )
                         Cut_CutRecycle( p, pCut );
                 goto finish;
@@ -737,7 +740,7 @@ Cut_Cut_t * Cut_NodeUnionCuts( Cut_Man_t * p, Vec_Int_t * vNodes )
         }
     } 
     // collect larger cuts next
-    Vec_PtrForEachEntry( p->vTemp, pList, i )
+    Vec_PtrForEachEntry( Cut_Cut_t *, p->vTemp, pList, i )
     {
         Cut_ListForEachCutSafe( pList, pCut, pCut2 )
         {
@@ -756,7 +759,7 @@ Cut_Cut_t * Cut_NodeUnionCuts( Cut_Man_t * p, Vec_Int_t * vNodes )
                 Cut_ListForEachCutSafe( pListStart, pCut, pCut2 )
                     Cut_CutRecycle( p, pCut );
                 // recycle the saved cuts of other nodes
-                Vec_PtrForEachEntryStart( p->vTemp, pList, k, i+1 )
+                Vec_PtrForEachEntryStart( Cut_Cut_t *, p->vTemp, pList, k, i+1 )
                     Cut_ListForEachCutSafe( pList, pCut, pCut2 )
                         Cut_CutRecycle( p, pCut );
                 goto finish;
@@ -885,7 +888,7 @@ Cut_Cut_t * Cut_NodeUnionCutsSeq( Cut_Man_t * p, Vec_Int_t * vNodes, int CutSetN
                 Vec_IntForEachEntryStart( vNodes, Node, k, i+1 )
                     Cut_NodeFreeCuts( p, Node );
                 // recycle the saved cuts of other nodes
-                Vec_PtrForEachEntry( p->vTemp, pList, k )
+                Vec_PtrForEachEntry( Cut_Cut_t *, p->vTemp, pList, k )
                     Cut_ListForEachCutSafe( pList, pCut, pCut2 )
                         Cut_CutRecycle( p, pCut );
                 goto finish;
@@ -893,7 +896,7 @@ Cut_Cut_t * Cut_NodeUnionCutsSeq( Cut_Man_t * p, Vec_Int_t * vNodes, int CutSetN
         }
     } 
     // collect larger cuts next
-    Vec_PtrForEachEntry( p->vTemp, pList, i )
+    Vec_PtrForEachEntry( Cut_Cut_t *, p->vTemp, pList, i )
     {
         Cut_ListForEachCutSafe( pList, pCut, pCut2 )
         {
@@ -925,7 +928,7 @@ Cut_Cut_t * Cut_NodeUnionCutsSeq( Cut_Man_t * p, Vec_Int_t * vNodes, int CutSetN
                 Cut_ListForEachCutSafe( pListStart, pCut, pCut2 )
                     Cut_CutRecycle( p, pCut );
                 // recycle the saved cuts of other nodes
-                Vec_PtrForEachEntryStart( p->vTemp, pList, k, i+1 )
+                Vec_PtrForEachEntryStart( Cut_Cut_t *, p->vTemp, pList, k, i+1 )
                     Cut_ListForEachCutSafe( pList, pCut, pCut2 )
                         Cut_CutRecycle( p, pCut );
                 goto finish;
@@ -997,3 +1000,5 @@ int Cut_CutListVerify( Cut_Cut_t * pList )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/cut/cutOracle.c b/src/opt/cut/cutOracle.c
index 32798f4f..f7883e3f 100644
--- a/src/opt/cut/cutOracle.c
+++ b/src/opt/cut/cutOracle.c
@@ -20,6 +20,9 @@
 
 #include "cutInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -133,7 +136,7 @@ void Cut_OracleStop( Cut_Oracle_t * p )
         ABC_PRT( "Total time ", p->timeTotal );
     }
 
-    Vec_PtrForEachEntry( p->vCutsNew, pCut, i )
+    Vec_PtrForEachEntry( Cut_Cut_t *, p->vCutsNew, pCut, i )
 
     if ( p->vCuts0 )      Vec_PtrFree( p->vCuts0 );
     if ( p->vCuts1 )      Vec_PtrFree( p->vCuts1 );
@@ -327,8 +330,8 @@ Cut_Cut_t * Cut_OracleComputeCuts( Cut_Oracle_t * p, int Node, int Node0, int No
     int clk = clock();
 
     // get the cuts of the children
-    pList0 = Vec_PtrEntry( p->vCutsNew, Node0 );
-    pList1 = Vec_PtrEntry( p->vCutsNew, Node1 );
+    pList0 = (Cut_Cut_t *)Vec_PtrEntry( p->vCutsNew, Node0 );
+    pList1 = (Cut_Cut_t *)Vec_PtrEntry( p->vCutsNew, Node1 );
     assert( pList0 && pList1 );
 
     // get the complemented attribute of the cut
@@ -355,8 +358,8 @@ Cut_Cut_t * Cut_OracleComputeCuts( Cut_Oracle_t * p, int Node, int Node0, int No
     for ( i = 1; i < nCuts; i++ )
     {
         Entry = Vec_IntEntry( p->vCutPairs, iCutStart + i );
-        pCut0 = Vec_PtrEntry( p->vCuts0, Entry & 0xFFFF );
-        pCut1 = Vec_PtrEntry( p->vCuts1, Entry >> 16 );
+        pCut0 = (Cut_Cut_t *)Vec_PtrEntry( p->vCuts0, Entry & 0xFFFF );
+        pCut1 = (Cut_Cut_t *)Vec_PtrEntry( p->vCuts1, Entry >> 16 );
         pCut  = Cut_CutMerge( p, pCut0, pCut1 );
         *ppTail = pCut;
         ppTail = &pCut->pNext;
@@ -387,7 +390,7 @@ p->timeTotal += clock() - clk;
 void Cut_OracleFreeCuts( Cut_Oracle_t * p, int Node )
 {
     Cut_Cut_t * pList, * pCut, * pCut2;
-    pList = Vec_PtrEntry( p->vCutsNew, Node );
+    pList = (Cut_Cut_t *)Vec_PtrEntry( p->vCutsNew, Node );
     if ( pList == NULL )
         return;
     Cut_ListForEachCutSafe( pList, pCut, pCut2 )
@@ -422,3 +425,5 @@ void Cut_OracleTryDroppingCuts( Cut_Oracle_t * p, int Node )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/cut/cutPre22.c b/src/opt/cut/cutPre22.c
index bda612f7..fdb9bd8c 100644
--- a/src/opt/cut/cutPre22.c
+++ b/src/opt/cut/cutPre22.c
@@ -20,6 +20,9 @@
 
 #include "cutInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -773,7 +776,7 @@ Cut_CMan_t * Cut_CManStart()
     p = ABC_ALLOC( Cut_CMan_t, 1 );
     memset( p, 0, sizeof(Cut_CMan_t) );
     // start the table and the memory manager
-    p->tTable = st_init_table(st_ptrcmp,st_ptrhash);
+    p->tTable = st_init_table(st_ptrcmp, st_ptrhash);;
     p->pMem = Extra_MmFixedStart( sizeof(Cut_Cell_t) );
     // set elementary truth tables
     for ( k = 0; k < CUT_CELL_MVAR; k++ )
@@ -986,3 +989,5 @@ int Cut_CellTruthLookup( unsigned * pTruth, int nVars )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/cut/cutSeq.c b/src/opt/cut/cutSeq.c
index d36f94f7..3f671d24 100644
--- a/src/opt/cut/cutSeq.c
+++ b/src/opt/cut/cutSeq.c
@@ -20,6 +20,9 @@
 
 #include "cutInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -225,3 +228,5 @@ void Cut_NodeOldTransferToNew( Cut_Man_t * p, int Node )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/cut/cutTruth.c b/src/opt/cut/cutTruth.c
index 6ecf20e4..3cbee3f6 100644
--- a/src/opt/cut/cutTruth.c
+++ b/src/opt/cut/cutTruth.c
@@ -20,6 +20,9 @@
 
 #include "cutInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 /* 
     Truth tables computed in this package are represented as bit-strings
     stored in the cut data structure. Cuts of any number of inputs have 
@@ -225,3 +228,5 @@ void Cut_TruthCompute( Cut_Man_t * p, Cut_Cut_t * pCut, Cut_Cut_t * pCut0, Cut_C
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/dec/dec.h b/src/opt/dec/dec.h
index 4042ac65..543fabf1 100644
--- a/src/opt/dec/dec.h
+++ b/src/opt/dec/dec.h
@@ -21,6 +21,7 @@
 #ifndef __DEC_H__
 #define __DEC_H__
 
+
 ////////////////////////////////////////////////////////////////////////
 ///                          INCLUDES                                ///
 ////////////////////////////////////////////////////////////////////////
@@ -29,9 +30,10 @@
 ///                         PARAMETERS                               ///
 ////////////////////////////////////////////////////////////////////////
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+
+
+ABC_NAMESPACE_HEADER_START
+
 
 ////////////////////////////////////////////////////////////////////////
 ///                         BASIC TYPES                              ///
@@ -50,7 +52,8 @@ struct Dec_Node_t_
     Dec_Edge_t        eEdge0;          // the left child of the node
     Dec_Edge_t        eEdge1;          // the right child of the node
     // other info
-    void *            pFunc;           // the function of the node (BDD or AIG)
+    union { int       iFunc;           // the literal of the node (AIG)
+    void *            pFunc; };        // the function of the node (BDD or AIG)
     unsigned          Level    : 14;   // the level of this node in the global AIG
     // printing info 
     unsigned          fNodeOr  :  1;   // marks the original OR node
@@ -177,10 +180,13 @@ static inline Dec_Edge_t Dec_IntToEdge( unsigned Edge )
   SeeAlso     []
 
 ***********************************************************************/
+static inline unsigned    Dec_EdgeToInt_( Dec_Edge_t m )  { union { Dec_Edge_t x; unsigned y; } v; v.x = m; return v.y;  }
+/*
 static inline unsigned Dec_EdgeToInt_( Dec_Edge_t eEdge )   
 {
     return *(unsigned *)&eEdge;
 }
+*/
 
 /**Function*************************************************************
 
@@ -193,10 +199,13 @@ static inline unsigned Dec_EdgeToInt_( Dec_Edge_t eEdge )
   SeeAlso     []
 
 ***********************************************************************/
+static inline Dec_Edge_t  Dec_IntToEdge_( unsigned m )    { union { Dec_Edge_t x; unsigned y; } v; v.y = m; return v.x;  }
+/*
 static inline Dec_Edge_t Dec_IntToEdge_( unsigned Edge )   
 {
     return *(Dec_Edge_t *)&Edge;
 }
+*/
 
 /**Function*************************************************************
 
@@ -702,9 +711,11 @@ static inline Dec_Edge_t Dec_GraphAddNodeMux( Dec_Graph_t * pGraph, Dec_Edge_t e
     return eNode;
 }
 
-#ifdef __cplusplus
-}
-#endif
+
+
+ABC_NAMESPACE_HEADER_END
+
+
 
 #endif
 
diff --git a/src/opt/dec/decAbc.c b/src/opt/dec/decAbc.c
index 158dc70a..24bfc9a8 100644
--- a/src/opt/dec/decAbc.c
+++ b/src/opt/dec/decAbc.c
@@ -20,6 +20,9 @@
 #include "dec.h"
 #include "ivy.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -50,16 +53,16 @@ Abc_Obj_t * Dec_GraphToNetwork( Abc_Ntk_t * pNtk, Dec_Graph_t * pGraph )
         return Abc_ObjNotCond( Abc_AigConst1(pNtk), Dec_GraphIsComplement(pGraph) );
     // check for a literal
     if ( Dec_GraphIsVar(pGraph) )
-        return Abc_ObjNotCond( Dec_GraphVar(pGraph)->pFunc, Dec_GraphIsComplement(pGraph) );
+        return Abc_ObjNotCond( (Abc_Obj_t *)Dec_GraphVar(pGraph)->pFunc, Dec_GraphIsComplement(pGraph) );
     // build the AIG nodes corresponding to the AND gates of the graph
     Dec_GraphForEachNode( pGraph, pNode, i )
     {
-        pAnd0 = Abc_ObjNotCond( Dec_GraphNode(pGraph, pNode->eEdge0.Node)->pFunc, pNode->eEdge0.fCompl ); 
-        pAnd1 = Abc_ObjNotCond( Dec_GraphNode(pGraph, pNode->eEdge1.Node)->pFunc, pNode->eEdge1.fCompl ); 
-        pNode->pFunc = Abc_AigAnd( pNtk->pManFunc, pAnd0, pAnd1 );
+        pAnd0 = Abc_ObjNotCond( (Abc_Obj_t *)Dec_GraphNode(pGraph, pNode->eEdge0.Node)->pFunc, pNode->eEdge0.fCompl ); 
+        pAnd1 = Abc_ObjNotCond( (Abc_Obj_t *)Dec_GraphNode(pGraph, pNode->eEdge1.Node)->pFunc, pNode->eEdge1.fCompl ); 
+        pNode->pFunc = Abc_AigAnd( (Abc_Aig_t *)pNtk->pManFunc, pAnd0, pAnd1 );
     }
     // complement the result if necessary
-    return Abc_ObjNotCond( pNode->pFunc, Dec_GraphIsComplement(pGraph) );
+    return Abc_ObjNotCond( (Abc_Obj_t *)pNode->pFunc, Dec_GraphIsComplement(pGraph) );
 }
 
 /**Function*************************************************************
@@ -131,20 +134,20 @@ Abc_Obj_t * Dec_GraphToNetworkNoStrash( Abc_Ntk_t * pNtk, Dec_Graph_t * pGraph )
         return Abc_ObjNotCond( Abc_AigConst1(pNtk), Dec_GraphIsComplement(pGraph) );
     // check for a literal
     if ( Dec_GraphIsVar(pGraph) )
-        return Abc_ObjNotCond( Dec_GraphVar(pGraph)->pFunc, Dec_GraphIsComplement(pGraph) );
+        return Abc_ObjNotCond( (Abc_Obj_t *)Dec_GraphVar(pGraph)->pFunc, Dec_GraphIsComplement(pGraph) );
     // build the AIG nodes corresponding to the AND gates of the graph
     Dec_GraphForEachNode( pGraph, pNode, i )
     {
-        pAnd0 = Abc_ObjNotCond( Dec_GraphNode(pGraph, pNode->eEdge0.Node)->pFunc, pNode->eEdge0.fCompl ); 
-        pAnd1 = Abc_ObjNotCond( Dec_GraphNode(pGraph, pNode->eEdge1.Node)->pFunc, pNode->eEdge1.fCompl ); 
-//        pNode->pFunc = Abc_AigAnd( pNtk->pManFunc, pAnd0, pAnd1 );
+        pAnd0 = Abc_ObjNotCond( (Abc_Obj_t *)Dec_GraphNode(pGraph, pNode->eEdge0.Node)->pFunc, pNode->eEdge0.fCompl ); 
+        pAnd1 = Abc_ObjNotCond( (Abc_Obj_t *)Dec_GraphNode(pGraph, pNode->eEdge1.Node)->pFunc, pNode->eEdge1.fCompl ); 
+//        pNode->pFunc = Abc_AigAnd( (Abc_Aig_t *)pNtk->pManFunc, pAnd0, pAnd1 );
         pAnd = Abc_NtkCreateNode( pNtk );
         Abc_ObjAddFanin( pAnd, pAnd0 );
         Abc_ObjAddFanin( pAnd, pAnd1 );
         pNode->pFunc = pAnd;
     }
     // complement the result if necessary
-    return Abc_ObjNotCond( pNode->pFunc, Dec_GraphIsComplement(pGraph) );
+    return Abc_ObjNotCond( (Abc_Obj_t *)pNode->pFunc, Dec_GraphIsComplement(pGraph) );
 }
 
 /**Function*************************************************************
@@ -163,7 +166,7 @@ Abc_Obj_t * Dec_GraphToNetworkNoStrash( Abc_Ntk_t * pNtk, Dec_Graph_t * pGraph )
 ***********************************************************************/
 int Dec_GraphToNetworkCount( Abc_Obj_t * pRoot, Dec_Graph_t * pGraph, int NodeMax, int LevelMax )
 {
-    Abc_Aig_t * pMan = pRoot->pNtk->pManFunc;
+    Abc_Aig_t * pMan = (Abc_Aig_t *)pRoot->pNtk->pManFunc;
     Dec_Node_t * pNode, * pNode0, * pNode1;
     Abc_Obj_t * pAnd, * pAnd0, * pAnd1;
     int i, Counter, LevelNew, LevelOld;
@@ -172,7 +175,7 @@ int Dec_GraphToNetworkCount( Abc_Obj_t * pRoot, Dec_Graph_t * pGraph, int NodeMa
         return 0;
     // set the levels of the leaves
     Dec_GraphForEachLeaf( pGraph, pNode, i )
-        pNode->Level = Abc_ObjRegular(pNode->pFunc)->Level;
+        pNode->Level = Abc_ObjRegular((Abc_Obj_t *)pNode->pFunc)->Level;
     // compute the AIG size after adding the internal nodes
     Counter = 0;
     Dec_GraphForEachNode( pGraph, pNode, i )
@@ -181,8 +184,8 @@ int Dec_GraphToNetworkCount( Abc_Obj_t * pRoot, Dec_Graph_t * pGraph, int NodeMa
         pNode0 = Dec_GraphNode( pGraph, pNode->eEdge0.Node );
         pNode1 = Dec_GraphNode( pGraph, pNode->eEdge1.Node );
         // get the AIG nodes corresponding to the children 
-        pAnd0 = pNode0->pFunc; 
-        pAnd1 = pNode1->pFunc; 
+        pAnd0 = (Abc_Obj_t *)pNode0->pFunc; 
+        pAnd1 = (Abc_Obj_t *)pNode1->pFunc; 
         if ( pAnd0 && pAnd1 )
         {
             // if they are both present, find the resulting node
@@ -234,7 +237,7 @@ int Dec_GraphToNetworkCount( Abc_Obj_t * pRoot, Dec_Graph_t * pGraph, int NodeMa
   SeeAlso     []
 
 ***********************************************************************/
-void Dec_GraphUpdateNetwork( Abc_Obj_t * pRoot, Dec_Graph_t * pGraph, bool fUpdateLevel, int nGain )
+void Dec_GraphUpdateNetwork( Abc_Obj_t * pRoot, Dec_Graph_t * pGraph, int fUpdateLevel, int nGain )
 {
     extern Abc_Obj_t *    Dec_GraphToNetwork( Abc_Ntk_t * pNtk, Dec_Graph_t * pGraph );
     Abc_Obj_t * pRootNew;
@@ -244,7 +247,7 @@ void Dec_GraphUpdateNetwork( Abc_Obj_t * pRoot, Dec_Graph_t * pGraph, bool fUpda
     // create the new structure of nodes
     pRootNew = Dec_GraphToNetwork( pNtk, pGraph );
     // remove the old nodes
-    Abc_AigReplace( pNtk->pManFunc, pRoot, pRootNew, fUpdateLevel );
+    Abc_AigReplace( (Abc_Aig_t *)pNtk->pManFunc, pRoot, pRootNew, fUpdateLevel );
     // compare the gains
     nNodesNew = Abc_NtkNodeNum(pNtk);
     assert( nGain <= nNodesOld - nNodesNew );
@@ -272,16 +275,16 @@ Hop_Obj_t * Dec_GraphToNetworkAig( Hop_Man_t * pMan, Dec_Graph_t * pGraph )
         return Hop_NotCond( Hop_ManConst1(pMan), Dec_GraphIsComplement(pGraph) );
     // check for a literal
     if ( Dec_GraphIsVar(pGraph) )
-        return Hop_NotCond( Dec_GraphVar(pGraph)->pFunc, Dec_GraphIsComplement(pGraph) );
+        return Hop_NotCond( (Hop_Obj_t *)Dec_GraphVar(pGraph)->pFunc, Dec_GraphIsComplement(pGraph) );
     // build the AIG nodes corresponding to the AND gates of the graph
     Dec_GraphForEachNode( pGraph, pNode, i )
     {
-        pAnd0 = Hop_NotCond( Dec_GraphNode(pGraph, pNode->eEdge0.Node)->pFunc, pNode->eEdge0.fCompl ); 
-        pAnd1 = Hop_NotCond( Dec_GraphNode(pGraph, pNode->eEdge1.Node)->pFunc, pNode->eEdge1.fCompl ); 
+        pAnd0 = Hop_NotCond( (Hop_Obj_t *)Dec_GraphNode(pGraph, pNode->eEdge0.Node)->pFunc, pNode->eEdge0.fCompl ); 
+        pAnd1 = Hop_NotCond( (Hop_Obj_t *)Dec_GraphNode(pGraph, pNode->eEdge1.Node)->pFunc, pNode->eEdge1.fCompl ); 
         pNode->pFunc = Hop_And( pMan, pAnd0, pAnd1 );
     }
     // complement the result if necessary
-    return Hop_NotCond( pNode->pFunc, Dec_GraphIsComplement(pGraph) );
+    return Hop_NotCond( (Hop_Obj_t *)pNode->pFunc, Dec_GraphIsComplement(pGraph) );
 }
 
 /**Function*************************************************************
@@ -333,16 +336,16 @@ Ivy_Obj_t * Dec_GraphToNetworkIvy( Ivy_Man_t * pMan, Dec_Graph_t * pGraph )
         return Ivy_NotCond( Ivy_ManConst1(pMan), Dec_GraphIsComplement(pGraph) );
     // check for a literal
     if ( Dec_GraphIsVar(pGraph) )
-        return Ivy_NotCond( Dec_GraphVar(pGraph)->pFunc, Dec_GraphIsComplement(pGraph) );
+        return Ivy_NotCond( (Ivy_Obj_t *)Dec_GraphVar(pGraph)->pFunc, Dec_GraphIsComplement(pGraph) );
     // build the AIG nodes corresponding to the AND gates of the graph
     Dec_GraphForEachNode( pGraph, pNode, i )
     {
-        pAnd0 = Ivy_NotCond( Dec_GraphNode(pGraph, pNode->eEdge0.Node)->pFunc, pNode->eEdge0.fCompl ); 
-        pAnd1 = Ivy_NotCond( Dec_GraphNode(pGraph, pNode->eEdge1.Node)->pFunc, pNode->eEdge1.fCompl ); 
+        pAnd0 = Ivy_NotCond( (Ivy_Obj_t *)Dec_GraphNode(pGraph, pNode->eEdge0.Node)->pFunc, pNode->eEdge0.fCompl ); 
+        pAnd1 = Ivy_NotCond( (Ivy_Obj_t *)Dec_GraphNode(pGraph, pNode->eEdge1.Node)->pFunc, pNode->eEdge1.fCompl ); 
         pNode->pFunc = Ivy_And( pMan, pAnd0, pAnd1 );
     }
     // complement the result if necessary
-    return Ivy_NotCond( pNode->pFunc, Dec_GraphIsComplement(pGraph) );
+    return Ivy_NotCond( (Ivy_Obj_t *)pNode->pFunc, Dec_GraphIsComplement(pGraph) );
 }
 
 
@@ -351,3 +354,5 @@ Ivy_Obj_t * Dec_GraphToNetworkIvy( Ivy_Man_t * pMan, Dec_Graph_t * pGraph )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/dec/decFactor.c b/src/opt/dec/decFactor.c
index 16e65b79..aa9d9c8a 100644
--- a/src/opt/dec/decFactor.c
+++ b/src/opt/dec/decFactor.c
@@ -21,6 +21,9 @@
 #include "mvc.h"
 #include "dec.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -57,7 +60,7 @@ Dec_Graph_t * Dec_Factor( char * pSop )
     // derive the cover from the SOP representation
     pCover = Dec_ConvertSopToMvc( pSop );
 
-    // make sure the cover is CCS ABC_FREE (should be done before CST)
+    // make sure the cover is CCS free (should be done before CST)
     Mvc_CoverContain( pCover );
     // check for trivial functions
     if ( Mvc_CoverIsEmpty(pCover) )
@@ -183,7 +186,7 @@ Dec_Edge_t Dec_Factor_rec( Dec_Graph_t * pFForm, Mvc_Cover_t * pCover )
 ***********************************************************************/
 Dec_Edge_t Dec_FactorLF_rec( Dec_Graph_t * pFForm, Mvc_Cover_t * pCover, Mvc_Cover_t * pSimple )
 {
-    Dec_Man_t * pManDec = Abc_FrameReadManDec();
+    Dec_Man_t * pManDec = (Dec_Man_t *)Abc_FrameReadManDec();
     Vec_Int_t * vEdgeLits  = pManDec->vLits;
     Mvc_Cover_t * pDiv, * pQuo, * pRem;
     Dec_Edge_t eNodeDiv, eNodeQuo, eNodeRem;
@@ -228,7 +231,7 @@ Dec_Edge_t Dec_FactorLF_rec( Dec_Graph_t * pFForm, Mvc_Cover_t * pCover, Mvc_Cov
 ***********************************************************************/
 Dec_Edge_t Dec_FactorTrivial( Dec_Graph_t * pFForm, Mvc_Cover_t * pCover )
 {
-    Dec_Man_t * pManDec = Abc_FrameReadManDec();
+    Dec_Man_t * pManDec = (Dec_Man_t *)Abc_FrameReadManDec();
     Vec_Int_t * vEdgeCubes = pManDec->vCubes;
     Vec_Int_t * vEdgeLits  = pManDec->vLits;
     Dec_Edge_t eNode;
@@ -321,8 +324,8 @@ Dec_Edge_t Dec_FactorTrivialTree_rec( Dec_Graph_t * pFForm, Dec_Edge_t * peNodes
 ***********************************************************************/
 Mvc_Cover_t * Dec_ConvertSopToMvc( char * pSop )
 {
-    Dec_Man_t * pManDec = Abc_FrameReadManDec();
-    Mvc_Manager_t * pMem = pManDec->pMvcMem;
+    Dec_Man_t * pManDec = (Dec_Man_t *)Abc_FrameReadManDec();
+    Mvc_Manager_t * pMem = (Mvc_Manager_t *)pManDec->pMvcMem;
     Mvc_Cover_t * pMvc;
     Mvc_Cube_t * pMvcCube;
     char * pCube;
@@ -364,7 +367,7 @@ Mvc_Cover_t * Dec_ConvertSopToMvc( char * pSop )
 int Dec_FactorVerify( char * pSop, Dec_Graph_t * pFForm )
 {
     extern DdNode *       Dec_GraphDeriveBdd( DdManager * dd, Dec_Graph_t * pGraph );
-    DdManager * dd = Abc_FrameReadManDd();
+    DdManager * dd = (DdManager *)Abc_FrameReadManDd();
     DdNode * bFunc1, * bFunc2;
     int RetValue;
     bFunc1 = Abc_ConvertSopToBdd( dd, pSop );    Cudd_Ref( bFunc1 );
@@ -390,3 +393,5 @@ int Dec_FactorVerify( char * pSop, Dec_Graph_t * pFForm )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/dec/decMan.c b/src/opt/dec/decMan.c
index 63a96966..8b6fae65 100644
--- a/src/opt/dec/decMan.c
+++ b/src/opt/dec/decMan.c
@@ -20,6 +20,9 @@
 #include "mvc.h"
 #include "dec.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -66,7 +69,7 @@ Dec_Man_t * Dec_ManStart()
 ***********************************************************************/
 void Dec_ManStop( Dec_Man_t * p )
 {
-    Mvc_ManagerFree( p->pMvcMem );
+    Mvc_ManagerFree( (Mvc_Manager_t *)p->pMvcMem );
     Vec_IntFree( p->vCubes );
     Vec_IntFree( p->vLits );
     ABC_FREE( p->puCanons );
@@ -81,3 +84,5 @@ void Dec_ManStop( Dec_Man_t * p )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/dec/decPrint.c b/src/opt/dec/decPrint.c
index 2d8f09b3..3cc0f811 100644
--- a/src/opt/dec/decPrint.c
+++ b/src/opt/dec/decPrint.c
@@ -19,6 +19,9 @@
 #include "abc.h"
 #include "dec.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -282,3 +285,5 @@ int Dec_GraphPrintOutputName( FILE * pFile, char * pNameOut, int fCompl )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/dec/decUtil.c b/src/opt/dec/decUtil.c
index b8ae4b8a..adf216f6 100644
--- a/src/opt/dec/decUtil.c
+++ b/src/opt/dec/decUtil.c
@@ -19,6 +19,9 @@
 #include "abc.h"
 #include "dec.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -64,13 +67,13 @@ DdNode * Dec_GraphDeriveBdd( DdManager * dd, Dec_Graph_t * pGraph )
     {
         bFunc0 = Cudd_NotCond( Dec_GraphNode(pGraph, pNode->eEdge0.Node)->pFunc, pNode->eEdge0.fCompl ); 
         bFunc1 = Cudd_NotCond( Dec_GraphNode(pGraph, pNode->eEdge1.Node)->pFunc, pNode->eEdge1.fCompl ); 
-        pNode->pFunc = Cudd_bddAnd( dd, bFunc0, bFunc1 );   Cudd_Ref( pNode->pFunc );
+        pNode->pFunc = Cudd_bddAnd( dd, bFunc0, bFunc1 );   Cudd_Ref( (DdNode *)pNode->pFunc );
     }
 
     // deref the intermediate results
-    bFunc = pNode->pFunc;   Cudd_Ref( bFunc );
+    bFunc = (DdNode *)pNode->pFunc;   Cudd_Ref( bFunc );
     Dec_GraphForEachNode( pGraph, pNode, i )
-        Cudd_RecursiveDeref( dd, pNode->pFunc );
+        Cudd_RecursiveDeref( dd, (DdNode *)pNode->pFunc );
     Cudd_Deref( bFunc );
 
     // complement the result if necessary
@@ -133,3 +136,5 @@ unsigned Dec_GraphDeriveTruth( Dec_Graph_t * pGraph )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/fret/fretFlow.c b/src/opt/fret/fretFlow.c
index 4b2bd936..498cb962 100644
--- a/src/opt/fret/fretFlow.c
+++ b/src/opt/fret/fretFlow.c
@@ -22,6 +22,9 @@
 #include "vec.h"
 #include "fretime.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -60,7 +63,7 @@ void dfsfast_preorder( Abc_Ntk_t *pNtk ) {
   // create reverse timing edges for backward traversal
 #if !defined(IGNORE_TIMING)
   if (pManMR->maxDelay) {
-    Abc_NtkForEachObj( pNtk, pObj, i ) {
+    Vec_PtrForEachEntry( Abc_Obj_t *, pNtk, pObj, i ) {
       Vec_PtrForEachEntry( FTIMEEDGES(pObj), pNext, j ) {
         vTimeIn = FDATA(pNext)->vNodes;
         if (!vTimeIn) {
@@ -77,7 +80,7 @@ void dfsfast_preorder( Abc_Ntk_t *pNtk ) {
   memset(Vec_IntArray(pManMR->vSinkDistHist), 0, sizeof(int)*Vec_IntSize(pManMR->vSinkDistHist));
 
   // seed queue : latches, PIOs, and blocks
-  Abc_NtkForEachObj( pNtk, pObj, i )
+  Vec_PtrForEachEntry( Abc_Obj_t *, pNtk, pObj, i )
     if (Abc_ObjIsPo(pObj) ||
         Abc_ObjIsLatch(pObj) || 
         (pManMR->fIsForward && FTEST(pObj, BLOCK_OR_CONS) & pManMR->constraintMask)) {
@@ -180,7 +183,7 @@ void dfsfast_preorder( Abc_Ntk_t *pNtk ) {
   // free time edges
 #if !defined(IGNORE_TIMING)
   if (pManMR->maxDelay) {
-    Abc_NtkForEachObj( pNtk, pObj, i ) {
+    Vec_PtrForEachEntry( Abc_Obj_t *, pNtk, pObj, i ) {
       vTimeIn = FDATA(pObj)->vNodes;
       if (vTimeIn) {
         Vec_PtrFree(vTimeIn);
@@ -190,7 +193,7 @@ void dfsfast_preorder( Abc_Ntk_t *pNtk ) {
   }
 #endif
 
-  Abc_NtkForEachObj( pNtk, pObj, i ) {
+  Vec_PtrForEachEntry( Abc_Obj_t *, pNtk, pObj, i ) {
     Vec_IntAddToEntry(pManMR->vSinkDistHist, FDATA(pObj)->r_dist, 1);
     Vec_IntAddToEntry(pManMR->vSinkDistHist, FDATA(pObj)->e_dist, 1);
 
@@ -695,3 +698,5 @@ int dfsplain_r( Abc_Obj_t *pObj, Abc_Obj_t *pPred ) {
 #endif
   return 1;
 }
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/fret/fretInit.c b/src/opt/fret/fretInit.c
index 0c7b1e29..ce9adefa 100644
--- a/src/opt/fret/fretInit.c
+++ b/src/opt/fret/fretInit.c
@@ -25,6 +25,9 @@
 #include "mio.h"
 #include "hop.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 #undef DEBUG_PRINT_INIT_NTK
 
 
@@ -698,7 +701,7 @@ void Abc_FlowRetime_UpdateBackwardInit( Abc_Ntk_t * pNtk ) {
   }  
 
   // recursively build init network
-  Vec_PtrForEachEntry( vBo, pOrigObj, i )
+  Vec_PtrForEachEntry( Abc_Obj_t *, vBo, pOrigObj, i )
     Abc_FlowRetime_UpdateBackwardInit_rec( pOrigObj );
   
   // clear flags
@@ -759,9 +762,9 @@ Abc_Obj_t *Abc_FlowRetime_CopyNodeToInitNtk( Abc_Obj_t *pOrigObj ) {
     fCompl[0] = pOrigObj->fCompl0 ? 1 : 0;
     fCompl[1] = pOrigObj->fCompl1 ? 1 : 0;
     
-    pData =  Abc_SopCreateAnd( pInitNtk->pManFunc, 2, fCompl );
+    pData =  Abc_SopCreateAnd( (Extra_MmFlex_t *)pInitNtk->pManFunc, 2, fCompl );
     assert(pData);
-    pInitObj->pData = Abc_SopRegister( pInitNtk->pManFunc, pData );
+    pInitObj->pData = Abc_SopRegister( (Extra_MmFlex_t *)pInitNtk->pManFunc, pData );
   } 
 
   // (ii) mapped node -> SOP node
@@ -779,7 +782,7 @@ Abc_Obj_t *Abc_FlowRetime_CopyNodeToInitNtk( Abc_Obj_t *pOrigObj ) {
     pData = Mio_GateReadSop(pOrigObj->pData);
     assert( Abc_SopGetVarNum(pData) == Abc_ObjFaninNum(pOrigObj) );
     
-    pInitObj->pData = Abc_SopRegister( pInitNtk->pManFunc, pData );
+    pInitObj->pData = Abc_SopRegister( (Extra_MmFlex_t *)pInitNtk->pManFunc, pData );
   } 
 
   // (iii) otherwise, duplicate obj
@@ -941,7 +944,7 @@ void Abc_FlowRetime_VerifyBackwardInit_rec( Abc_Obj_t * pObj ) {
   SeeAlso     []
 
 ***********************************************************************/
-bool Abc_FlowRetime_PartialSat(Vec_Ptr_t *vNodes, int cut) {
+int Abc_FlowRetime_PartialSat(Vec_Ptr_t *vNodes, int cut) {
   Abc_Ntk_t *pPartNtk, *pInitNtk = pManMR->pInitNtk;
   Abc_Obj_t *pObj, *pNext, *pPartObj, *pPartNext, *pPo;
   int i, j, result;
@@ -951,7 +954,7 @@ bool Abc_FlowRetime_PartialSat(Vec_Ptr_t *vNodes, int cut) {
   pPartNtk = Abc_NtkAlloc( pInitNtk->ntkType, pInitNtk->ntkFunc, 0 );
 
   // copy network
-  Vec_PtrForEachEntry( vNodes, pObj, i ) {
+  Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i ) {
     pObj->Level = i;
     assert(!Abc_ObjIsPo( pObj ));
 
@@ -1117,7 +1120,7 @@ void Abc_FlowRetime_RemoveInitBias( ) {
   InitConstraint_t *pConstraint;
   int i;
 
-  Vec_PtrForEachEntry( pManMR->vInitConstraints, pConstraint, i ) {
+  Vec_PtrForEachEntry( Abc_Obj_t *, pManMR->vInitConstraints, pConstraint, i ) {
     pBiasNode = pConstraint->pBiasNode;
     pConstraint->pBiasNode = NULL;
 
@@ -1215,7 +1218,7 @@ void Abc_FlowRetime_AddInitBias( ) {
 
   vprintf("\t\tcreating %d bias structures\n", nConstraints);
 
-  Vec_PtrForEachEntry( pManMR->vInitConstraints, pConstraint, i ) {
+  Vec_PtrForEachEntry( Abc_Obj_t *, pManMR->vInitConstraints, pConstraint, i ) {
     if (pConstraint->pBiasNode) continue;
     
  //   printf("\t\t\tbias %d...\n", i);
@@ -1327,3 +1330,5 @@ void Abc_FlowRetime_GetInitToOrig( Abc_Obj_t *pInit, Abc_Obj_t **pOrig, int *lag
   *pOrig = Abc_NtkObj(pManMR->pNtk, origId);
   *lag = pManMR->pInitToOrig[id].lag;
 }
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/fret/fretMain.c b/src/opt/fret/fretMain.c
index 77ea8468..141baff4 100644
--- a/src/opt/fret/fretMain.c
+++ b/src/opt/fret/fretMain.c
@@ -22,6 +22,9 @@
 #include "vec.h"
 #include "fretime.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -475,7 +478,7 @@ Abc_FlowRetime_MarkBlocks( Abc_Ntk_t * pNtk ) {
 
 ***********************************************************************/
 int
-Abc_FlowRetime_PushFlows( Abc_Ntk_t * pNtk, bool fVerbose ) {
+Abc_FlowRetime_PushFlows( Abc_Ntk_t * pNtk, int fVerbose ) {
   int i, j, flow = 0, last, srcDist = 0;
   Abc_Obj_t   *pObj, *pObj2;
 //  int clk = clock();
@@ -1049,7 +1052,7 @@ Abc_ObjBetterTransferFanout( Abc_Obj_t * pFrom, Abc_Obj_t * pTo, int compl ) {
   SeeAlso     []
 
 ***********************************************************************/
-bool
+int
 Abc_FlowRetime_IsAcrossCut( Abc_Obj_t *pObj, Abc_Obj_t *pNext ) {
 
   if (FTEST(pObj, VISITED_R) && !FTEST(pObj, VISITED_E)) {
@@ -1083,7 +1086,7 @@ Abc_FlowRetime_IsAcrossCut( Abc_Obj_t *pObj, Abc_Obj_t *pNext ) {
   SeeAlso     []
 
 ***********************************************************************/
-void Abc_FlowRetime_ClearFlows( bool fClearAll ) {
+void Abc_FlowRetime_ClearFlows( int fClearAll ) {
   int i;
 
   if (fClearAll)
@@ -1180,7 +1183,7 @@ static Abc_Ntk_t* Abc_FlowRetime_NtkDup( Abc_Ntk_t * pNtk ) {
   SeeAlso     []
 
 ***********************************************************************/
-Abc_Ntk_t * Abc_FlowRetime_NtkSilentRestrash( Abc_Ntk_t * pNtk, bool fCleanup )
+Abc_Ntk_t * Abc_FlowRetime_NtkSilentRestrash( Abc_Ntk_t * pNtk, int fCleanup )
 {
     Abc_Ntk_t * pNtkAig;
     Abc_Obj_t * pObj;
@@ -1190,12 +1193,12 @@ Abc_Ntk_t * Abc_FlowRetime_NtkSilentRestrash( Abc_Ntk_t * pNtk, bool fCleanup )
     pNtkAig = Abc_NtkStartFrom( pNtk, ABC_NTK_STRASH, ABC_FUNC_AIG );
     // restrash the nodes (assuming a topological order of the old network)
     Abc_NtkForEachNode( pNtk, pObj, i )
-        pObj->pCopy = Abc_AigAnd( pNtkAig->pManFunc, Abc_ObjChild0Copy(pObj), Abc_ObjChild1Copy(pObj) );
+        pObj->pCopy = Abc_AigAnd( (Abc_Aig_t *)pNtkAig->pManFunc, Abc_ObjChild0Copy(pObj), Abc_ObjChild1Copy(pObj) );
     // finalize the network
     Abc_NtkFinalize( pNtk, pNtkAig );
     // perform cleanup if requested
     if ( fCleanup )
-      nNodes = Abc_AigCleanup(pNtkAig->pManFunc);
+      nNodes = Abc_AigCleanup((Abc_Aig_t *)pNtkAig->pManFunc);
     // duplicate EXDC 
     if ( pNtk->pExdc )
       pNtkAig->pExdc = Abc_NtkDup( pNtk->pExdc );
@@ -1378,3 +1381,5 @@ void Abc_ObjPrintNeighborhood( Abc_Obj_t *pObj, int depth ) {
 
   Vec_PtrFree(vNodes);
 }
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/fret/fretTime.c b/src/opt/fret/fretTime.c
index f497df60..47e90519 100644
--- a/src/opt/fret/fretTime.c
+++ b/src/opt/fret/fretTime.c
@@ -22,6 +22,9 @@
 #include "vec.h"
 #include "fretime.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -131,7 +134,7 @@ void Abc_FlowRetime_ConstrainConserv_forw( Abc_Ntk_t * pNtk ) {
     Abc_FlowRetime_Dfs_forw( pObj, vNodes );
 
   // ... propagate values
-  Vec_PtrForEachEntryReverse(vNodes, pObj, i) {
+  Vec_PtrForEachEntryReverse( Abc_Obj_t *,vNodes, pObj, i) {
     pObj->Level = 0;
     Abc_ObjForEachFanin( pObj, pNext, j )
     {
@@ -168,19 +171,19 @@ void Abc_FlowRetime_ConstrainConserv_forw( Abc_Ntk_t * pNtk ) {
 
 #if defined(DEBUG_CHECK)
   // DEBUG: check DFS ordering
-  Vec_PtrForEachEntryReverse(vNodes, pObj, i) {
+  Vec_PtrForEachEntryReverse( Abc_Obj_t *,vNodes, pObj, i) {
     pObj->fMarkB = 1;
     
     Abc_ObjForEachFanin( pObj, pNext, j )
       if ( Abc_NodeIsTravIdCurrent(pNext) && !Abc_ObjIsLatch(pNext))
         assert(pNext->fMarkB);
   }
-  Vec_PtrForEachEntryReverse(vNodes, pObj, i)
+  Vec_PtrForEachEntryReverse( Abc_Obj_t *,vNodes, pObj, i)
     pObj->fMarkB = 0;
 #endif
 
   // ... propagate values
-  Vec_PtrForEachEntryReverse(vNodes, pObj, i) {
+  Vec_PtrForEachEntryReverse( Abc_Obj_t *,vNodes, pObj, i) {
     pObj->Level = 0;
     Abc_ObjForEachFanin( pObj, pNext, j )
     {
@@ -203,7 +206,7 @@ void Abc_FlowRetime_ConstrainConserv_forw( Abc_Ntk_t * pNtk ) {
   }
 
   // ... propagate values
-  Vec_PtrForEachEntryReverse(vNodes, pObj, i) {
+  Vec_PtrForEachEntryReverse( Abc_Obj_t *,vNodes, pObj, i) {
     pObj->Level = 0;
     Abc_ObjForEachFanin( pObj, pNext, j ) {
       if ( Abc_NodeIsTravIdCurrent(pNext) &&
@@ -231,7 +234,7 @@ void Abc_FlowRetime_ConstrainConserv_forw( Abc_Ntk_t * pNtk ) {
   }
 
   // ... propagate values
-  Vec_PtrForEachEntryReverse(vNodes, pObj, i) {
+  Vec_PtrForEachEntryReverse( Abc_Obj_t *,vNodes, pObj, i) {
     pObj->Level = 0;
     Abc_ObjForEachFanin( pObj, pNext, j ) {
       if ( Abc_NodeIsTravIdCurrent(pNext) &&
@@ -269,7 +272,7 @@ void Abc_FlowRetime_ConstrainConserv_back( Abc_Ntk_t * pNtk ) {
     Abc_FlowRetime_Dfs_back( pObj, vNodes );
 
   // ... propagate values
-  Vec_PtrForEachEntryReverse(vNodes, pObj, i) {
+  Vec_PtrForEachEntryReverse( Abc_Obj_t *,vNodes, pObj, i) {
     pObj->Level = 0;
     Abc_ObjForEachFanout( pObj, pNext, j )
     {
@@ -306,19 +309,19 @@ void Abc_FlowRetime_ConstrainConserv_back( Abc_Ntk_t * pNtk ) {
 
 #if defined(DEBUG_CHECK)
   // DEBUG: check DFS ordering
-  Vec_PtrForEachEntryReverse(vNodes, pObj, i) {
+  Vec_PtrForEachEntryReverse( Abc_Obj_t *,vNodes, pObj, i) {
     pObj->fMarkB = 1;
     
     Abc_ObjForEachFanout( pObj, pNext, j )
       if ( Abc_NodeIsTravIdCurrent(pNext) && !Abc_ObjIsLatch(pNext))
         assert(pNext->fMarkB);
   }
-  Vec_PtrForEachEntryReverse(vNodes, pObj, i)
+  Vec_PtrForEachEntryReverse( Abc_Obj_t *,vNodes, pObj, i)
     pObj->fMarkB = 0;
 #endif
 
   // ... propagate values
-  Vec_PtrForEachEntryReverse(vNodes, pObj, i) {
+  Vec_PtrForEachEntryReverse( Abc_Obj_t *,vNodes, pObj, i) {
     pObj->Level = 0;
     Abc_ObjForEachFanout( pObj, pNext, j )
     {
@@ -341,7 +344,7 @@ void Abc_FlowRetime_ConstrainConserv_back( Abc_Ntk_t * pNtk ) {
   }
 
   // ... propagate values
-  Vec_PtrForEachEntryReverse(vNodes, pObj, i) {
+  Vec_PtrForEachEntryReverse( Abc_Obj_t *,vNodes, pObj, i) {
     pObj->Level = 0;
     Abc_ObjForEachFanout( pObj, pNext, j ) {
       l = pNext->Level + (Abc_ObjIsNode(pObj) ? 1 : 0);
@@ -371,7 +374,7 @@ void Abc_FlowRetime_ConstrainConserv_back( Abc_Ntk_t * pNtk ) {
   }
 
   // ... propagate values
-  Vec_PtrForEachEntryReverse(vNodes, pObj, i) {
+  Vec_PtrForEachEntryReverse( Abc_Obj_t *,vNodes, pObj, i) {
     pObj->Level = 0;
     Abc_ObjForEachFanout( pObj, pNext, j ) {
       l = pNext->Level + (Abc_ObjIsNode(pObj) ? 1 : 0);
@@ -462,7 +465,7 @@ void Abc_FlowRetime_ConstrainExact_forw( Abc_Obj_t * pObj ) {
   // rev topo order
   Abc_FlowRetime_ConstrainExact_forw_rec( pObj, vNodes, 0 );
 
-  Vec_PtrForEachEntryReverse( vNodes, pCur, i) {
+  Vec_PtrForEachEntryReverse( Abc_Obj_t *, vNodes, pCur, i) {
     pReg = Abc_ObjRegular( pCur );
 
     if (pReg == pCur) {
@@ -474,7 +477,7 @@ void Abc_FlowRetime_ConstrainExact_forw( Abc_Obj_t * pObj ) {
       pReg->fMarkA = pReg->fMarkB = 0;
     }
   }
-  Vec_PtrForEachEntryReverse( vNodes, pCur, i) {
+  Vec_PtrForEachEntryReverse( Abc_Obj_t *, vNodes, pCur, i) {
     pReg = Abc_ObjRegular( pCur );
     if (pReg != pCur) {
       Abc_ObjForEachFanin(pReg, pNext, j)
@@ -537,7 +540,7 @@ void Abc_FlowRetime_ConstrainExact_back( Abc_Obj_t * pObj ) {
   // rev topo order
   Abc_FlowRetime_ConstrainExact_back_rec( pObj, vNodes, 0 );
 
-  Vec_PtrForEachEntryReverse( vNodes, pCur, i) {
+  Vec_PtrForEachEntryReverse( Abc_Obj_t *, vNodes, pCur, i) {
     pReg = Abc_ObjRegular( pCur );
 
     if (pReg == pCur) {
@@ -549,7 +552,7 @@ void Abc_FlowRetime_ConstrainExact_back( Abc_Obj_t * pObj ) {
       pReg->fMarkA = pReg->fMarkB = 0;
     }
   }
-  Vec_PtrForEachEntryReverse( vNodes, pCur, i) {
+  Vec_PtrForEachEntryReverse( Abc_Obj_t *, vNodes, pCur, i) {
     pReg = Abc_ObjRegular( pCur );
     if (pReg != pCur) {
       Abc_ObjForEachFanout(pReg, pNext, j)
@@ -689,7 +692,7 @@ void Abc_FlowRetime_Dfs_back( Abc_Obj_t * pObj, Vec_Ptr_t *vNodes ) {
   SeeAlso     []
 
 ***********************************************************************/
-bool Abc_FlowRetime_RefineConstraints( ) {
+int Abc_FlowRetime_RefineConstraints( ) {
   Abc_Ntk_t *pNtk = pManMR->pNtk;
   int i, flow, count = 0;
   Abc_Obj_t *pObj;
@@ -761,3 +764,5 @@ bool Abc_FlowRetime_RefineConstraints( ) {
 }
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/fret/fretime.h b/src/opt/fret/fretime.h
index bbb79d26..2d70d7e3 100644
--- a/src/opt/fret/fretime.h
+++ b/src/opt/fret/fretime.h
@@ -21,8 +21,12 @@
 #if !defined(RETIME_H_)
 #define RETIME_H_
 
+
 #include "abc.h"
 
+ABC_NAMESPACE_HEADER_START
+
+
 // #define IGNORE_TIMING
 // #define DEBUG_PRINT_FLOWS
 // #define DEBUG_VISITED
@@ -89,19 +93,19 @@ typedef struct MinRegMan_t_ {
  
   // problem description:
   int         maxDelay;
-  bool        fComputeInitState, fGuaranteeInitState, fBlockConst;
+  int        fComputeInitState, fGuaranteeInitState, fBlockConst;
   int         nNodes, nLatches;
-  bool        fForwardOnly, fBackwardOnly;
-  bool        fConservTimingOnly;
+  int        fForwardOnly, fBackwardOnly;
+  int        fConservTimingOnly;
   int         nMaxIters;
-  bool        fVerbose;
+  int        fVerbose;
   Abc_Ntk_t  *pNtk;
 
   int         nPreRefine;
 
   // problem state
-  bool        fIsForward;
-  bool        fSinkDistTerminate;
+  int        fIsForward;
+  int        fSinkDistTerminate;
   int         nExactConstraints, nConservConstraints;
   int         fSolutionIsDc;
   int         constraintMask;
@@ -145,9 +149,9 @@ void print_node(Abc_Obj_t *pObj);
 
 void Abc_ObjBetterTransferFanout( Abc_Obj_t * pFrom, Abc_Obj_t * pTo, int compl );
 
-int  Abc_FlowRetime_PushFlows( Abc_Ntk_t * pNtk, bool fVerbose );
-bool Abc_FlowRetime_IsAcrossCut( Abc_Obj_t *pCur, Abc_Obj_t *pNext );
-void Abc_FlowRetime_ClearFlows( bool fClearAll );
+int  Abc_FlowRetime_PushFlows( Abc_Ntk_t * pNtk, int fVerbose );
+int Abc_FlowRetime_IsAcrossCut( Abc_Obj_t *pCur, Abc_Obj_t *pNext );
+void Abc_FlowRetime_ClearFlows( int fClearAll );
 
 int  Abc_FlowRetime_GetLag( Abc_Obj_t *pObj );
 void Abc_FlowRetime_SetLag( Abc_Obj_t *pObj, int lag );
@@ -156,7 +160,7 @@ void Abc_FlowRetime_UpdateLags( );
 
 void Abc_ObjPrintNeighborhood( Abc_Obj_t *pObj, int depth );
 
-Abc_Ntk_t * Abc_FlowRetime_NtkSilentRestrash( Abc_Ntk_t * pNtk, bool fCleanup );
+Abc_Ntk_t * Abc_FlowRetime_NtkSilentRestrash( Abc_Ntk_t * pNtk, int fCleanup );
 
 /*=== fretFlow.c ==========================================================*/
 
@@ -188,10 +192,14 @@ void Abc_FlowRetime_RemoveInitBias(  );
 void Abc_FlowRetime_InitTiming( Abc_Ntk_t *pNtk );
 void Abc_FlowRetime_FreeTiming( Abc_Ntk_t *pNtk );
 
-bool Abc_FlowRetime_RefineConstraints( );
+int Abc_FlowRetime_RefineConstraints( );
 
 void Abc_FlowRetime_ConstrainConserv( Abc_Ntk_t * pNtk );
 void Abc_FlowRetime_ConstrainExact( Abc_Obj_t * pObj );
 void Abc_FlowRetime_ConstrainExactAll( Abc_Ntk_t * pNtk );
 
+
+
+ABC_NAMESPACE_HEADER_END
+
 #endif
diff --git a/src/opt/fxu/fxu.c b/src/opt/fxu/fxu.c
index 9102d289..264a7898 100644
--- a/src/opt/fxu/fxu.c
+++ b/src/opt/fxu/fxu.c
@@ -19,6 +19,9 @@
 #include "fxuInt.h" 
 #include "fxu.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -252,3 +255,5 @@ void Fxu_MemRecycle( Fxu_Matrix * p, char * pItem, int nBytes )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/fxu/fxu.h b/src/opt/fxu/fxu.h
index b9a56b23..db855f3b 100644
--- a/src/opt/fxu/fxu.h
+++ b/src/opt/fxu/fxu.h
@@ -19,6 +19,7 @@
 #ifndef __FXU_H__
 #define __FXU_H__
 
+
 ////////////////////////////////////////////////////////////////////////
 ///                          INCLUDES                                ///
 ////////////////////////////////////////////////////////////////////////
@@ -29,31 +30,26 @@
 ///                         PARAMETERS                               ///
 ////////////////////////////////////////////////////////////////////////
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+
+
+ABC_NAMESPACE_HEADER_START
+
 
 ////////////////////////////////////////////////////////////////////////
 ///                    STRUCTURE DEFINITIONS                         ///
 ////////////////////////////////////////////////////////////////////////
 
-#ifndef __cplusplus
-#ifndef bool
-#define bool int
-#endif
-#endif
-
 typedef struct FxuDataStruct   Fxu_Data_t;
 
 // structure for the FX input/output data 
 struct FxuDataStruct
 {
     // user specified parameters
-    bool              fOnlyS;           // set to 1 to have only single-cube divs
-    bool              fOnlyD;           // set to 1 to have only double-cube divs
-    bool              fUse0;            // set to 1 to have 0-weight also extracted
-    bool              fUseCompl;        // set to 1 to have complement taken into account
-    bool              fVerbose;         // set to 1 to have verbose output
+    int               fOnlyS;           // set to 1 to have only single-cube divs
+    int               fOnlyD;           // set to 1 to have only double-cube divs
+    int               fUse0;            // set to 1 to have 0-weight also extracted
+    int               fUseCompl;        // set to 1 to have complement taken into account
+    int               fVerbose;         // set to 1 to have verbose output
     int               nNodesExt;        // the number of divisors to extract
     int               nSingleMax;       // the max number of single-cube divisors to consider
     int               nPairsMax;        // the max number of double-cube divisors to consider
@@ -81,9 +77,11 @@ struct FxuDataStruct
 /*===== fxu.c ==========================================================*/
 extern int          Fxu_FastExtract( Fxu_Data_t * pData );
 
-#ifdef __cplusplus
-}
-#endif
+
+
+ABC_NAMESPACE_HEADER_END
+
+
 
 #endif
 
diff --git a/src/opt/fxu/fxuCreate.c b/src/opt/fxu/fxuCreate.c
index 008cac46..3466b520 100644
--- a/src/opt/fxu/fxuCreate.c
+++ b/src/opt/fxu/fxuCreate.c
@@ -20,6 +20,9 @@
 #include "fxuInt.h"
 #include "fxu.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -71,7 +74,7 @@ Fxu_Matrix * Fxu_CreateMatrix( Fxu_Data_t * pData )
     nPairsStore =  0;
     nBitsMax    = -1; 
     for ( i = 0; i < pData->nNodesOld; i++ )
-        if ( (pSopCover = pData->vSops->pArray[i]) )
+        if ( (pSopCover = (char *)pData->vSops->pArray[i]) )
         {
             nCubes       = Abc_SopGetCubeNum( pSopCover );
             nFanins      = Abc_SopGetVarNum( pSopCover );
@@ -109,7 +112,7 @@ Fxu_Matrix * Fxu_CreateMatrix( Fxu_Data_t * pData )
     iCube = 0;
     iPair = 0;
     for ( i = 0; i < pData->nNodesOld; i++ )
-        if ( (pSopCover = pData->vSops->pArray[i]) )
+        if ( (pSopCover = (char *)pData->vSops->pArray[i]) )
         {
             // get the number of cubes
             nCubes = Abc_SopGetCubeNum( pSopCover );
@@ -136,14 +139,14 @@ Fxu_Matrix * Fxu_CreateMatrix( Fxu_Data_t * pData )
     pOrder = ABC_ALLOC( int, nBitsMax );
     // create the rows
     for ( i = 0; i < pData->nNodesOld; i++ )
-    if ( (pSopCover = pData->vSops->pArray[i]) )
+    if ( (pSopCover = (char *)pData->vSops->pArray[i]) )
     {
         // get the new var in the matrix
         pVar = p->ppVars[2*i+1];
         // here we sort the literals of the cover
         // in the increasing order of the numbers of the corresponding nodes
         // because literals should be added to the matrix in this order
-        vFanins = pData->vFanins->pArray[i];
+        vFanins = (Vec_Int_t *)pData->vFanins->pArray[i];
         s_pLits = vFanins->pArray;
         // start the variable order
         nFanins = Abc_SopGetVarNum( pSopCover );
@@ -272,7 +275,7 @@ void Fxu_CreateCovers( Fxu_Matrix * p, Fxu_Data_t * pData )
 
     // go through the internal nodes
     for ( n = 0; n < pData->nNodesOld; n++ )
-    if ( (pSopCover = pData->vSops->pArray[n]) )
+    if ( (pSopCover = (char *)pData->vSops->pArray[n]) )
     {
         // get the number of this node
         iNode = n;
@@ -358,7 +361,7 @@ void Fxu_CreateCoversNode( Fxu_Matrix * p, Fxu_Data_t * pData, int iNode, Fxu_Cu
     // allocate room for the new cover
     pSopCover = Abc_SopStart( pData->pManSop, nCubes, vInputsNew->nSize );
     // set the correct polarity of the cover
-    if ( iNode < pData->nNodesOld && Abc_SopGetPhase( pData->vSops->pArray[iNode] ) == 0 )
+    if ( iNode < pData->nNodesOld && Abc_SopGetPhase( (char *)pData->vSops->pArray[iNode] ) == 0 )
         Abc_SopComplement( pSopCover );
 
     // add the cubes
@@ -429,3 +432,5 @@ int Fxu_CreateMatrixLitCompare( int * ptrX, int * ptrY )
 ////////////////////////////////////////////////////////////////////////
 ///                       END OF FILE                                ///
 ////////////////////////////////////////////////////////////////////////
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/fxu/fxuHeapD.c b/src/opt/fxu/fxuHeapD.c
index 9a8eb124..cb022fc4 100644
--- a/src/opt/fxu/fxuHeapD.c
+++ b/src/opt/fxu/fxuHeapD.c
@@ -18,6 +18,9 @@
 
 #include "fxuInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -443,3 +446,5 @@ void Fxu_HeapDoubleMoveDn( Fxu_HeapDouble * p, Fxu_Double * pDiv )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/fxu/fxuHeapS.c b/src/opt/fxu/fxuHeapS.c
index 4a9bd3a4..ead8e914 100644
--- a/src/opt/fxu/fxuHeapS.c
+++ b/src/opt/fxu/fxuHeapS.c
@@ -18,6 +18,9 @@
 
 #include "fxuInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -442,3 +445,5 @@ void Fxu_HeapSingleMoveDn( Fxu_HeapSingle * p, Fxu_Single * pSingle )
 ////////////////////////////////////////////////////////////////////////
 ///                       END OF FILE                                ///
 ////////////////////////////////////////////////////////////////////////
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/fxu/fxuInt.h b/src/opt/fxu/fxuInt.h
index 7483c896..96bec083 100644
--- a/src/opt/fxu/fxuInt.h
+++ b/src/opt/fxu/fxuInt.h
@@ -19,6 +19,7 @@
 #ifndef __FXU_INT_H__
 #define __FXU_INT_H__
 
+
 ////////////////////////////////////////////////////////////////////////
 ///                          INCLUDES                                ///
 ////////////////////////////////////////////////////////////////////////
@@ -26,6 +27,9 @@
 #include "extra.h"
 #include "vec.h"
 
+ABC_NAMESPACE_HEADER_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                         PARAMETERS                               ///
 ////////////////////////////////////////////////////////////////////////
@@ -531,6 +535,10 @@ extern int          Fxu_HeapSingleReadMaxWeight( Fxu_HeapSingle * p );
 extern Fxu_Single * Fxu_HeapSingleReadMax( Fxu_HeapSingle * p );
 extern Fxu_Single * Fxu_HeapSingleGetMax( Fxu_HeapSingle * p );  
 
+
+
+ABC_NAMESPACE_HEADER_END
+
 #endif
 
 ////////////////////////////////////////////////////////////////////////
diff --git a/src/opt/fxu/fxuList.c b/src/opt/fxu/fxuList.c
index 52995804..7a7f27c8 100644
--- a/src/opt/fxu/fxuList.c
+++ b/src/opt/fxu/fxuList.c
@@ -18,6 +18,9 @@
 
 #include "fxuInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -520,3 +523,5 @@ void Fxu_ListDoubleAddPairPlace( Fxu_Double * pDiv, Fxu_Pair * pPair, Fxu_Pair *
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/fxu/fxuMatrix.c b/src/opt/fxu/fxuMatrix.c
index 590370c9..a53de0a3 100644
--- a/src/opt/fxu/fxuMatrix.c
+++ b/src/opt/fxu/fxuMatrix.c
@@ -18,6 +18,9 @@
 
 #include "fxuInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -372,3 +375,5 @@ void Fxu_MatrixAddDivisor( Fxu_Matrix * p, Fxu_Cube * pCube1, Fxu_Cube * pCube2
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/fxu/fxuPair.c b/src/opt/fxu/fxuPair.c
index 62cc792b..d040abe9 100644
--- a/src/opt/fxu/fxuPair.c
+++ b/src/opt/fxu/fxuPair.c
@@ -18,6 +18,9 @@
 
 #include "fxuInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -553,3 +556,5 @@ void Fxu_PairAdd( Fxu_Pair * pPair )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/fxu/fxuPrint.c b/src/opt/fxu/fxuPrint.c
index 652a830e..d7a4d38a 100644
--- a/src/opt/fxu/fxuPrint.c
+++ b/src/opt/fxu/fxuPrint.c
@@ -18,6 +18,9 @@
 
 #include "fxuInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -193,3 +196,5 @@ void Fxu_MatrixPrintDivisorProfile( FILE * pFile, Fxu_Matrix * p )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/fxu/fxuReduce.c b/src/opt/fxu/fxuReduce.c
index 6b892971..2321ec57 100644
--- a/src/opt/fxu/fxuReduce.c
+++ b/src/opt/fxu/fxuReduce.c
@@ -20,6 +20,9 @@
 #include "fxuInt.h"
 #include "fxu.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -40,7 +43,7 @@ static int Fxu_CountPairDiffs( char * pCover, unsigned char pDiffs[] );
   number of pairs in existence. This procedure adds to the storage of
   divisors exactly the given number of pairs (nPairsMax) while taking
   first those pairs that have the smallest number of literals in their
-  cube-ABC_FREE form.]
+  cube-free form.]
                
   SideEffects []
 
@@ -69,7 +72,7 @@ int Fxu_PreprocessCubePairs( Fxu_Matrix * p, Vec_Ptr_t * vCovers, int nPairsTota
     iPair    =  0;
     nBitsMax = -1;
     for ( c = 0; c < vCovers->nSize; c++ )
-        if ( (pSopCover = vCovers->pArray[c]) )
+        if ( (pSopCover = (char *)vCovers->pArray[c]) )
         {
             nFanins = Abc_SopGetVarNum(pSopCover);
             // precompute the differences
@@ -135,7 +138,7 @@ int Fxu_PreprocessCubePairs( Fxu_Matrix * p, Vec_Ptr_t * vCovers, int nPairsTota
     // collect the corresponding pairs and add the divisors
     iPair = 0;
     for ( c = 0; c < vCovers->nSize; c++ )
-        if ( (pSopCover = vCovers->pArray[c]) )
+        if ( (pSopCover = (char *)vCovers->pArray[c]) )
         {
             // get the var
             pVar = p->ppVars[2*c+1];
@@ -202,3 +205,5 @@ int Fxu_CountPairDiffs( char * pCover, unsigned char pDiffs[] )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/fxu/fxuSelect.c b/src/opt/fxu/fxuSelect.c
index 20f5ab97..a4e260c7 100644
--- a/src/opt/fxu/fxuSelect.c
+++ b/src/opt/fxu/fxuSelect.c
@@ -18,6 +18,9 @@
 
 #include "fxuInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -601,3 +604,5 @@ int Fxu_SelectSCD( Fxu_Matrix * p, int WeightLimit, Fxu_Var ** ppVar1, Fxu_Var *
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/fxu/fxuSingle.c b/src/opt/fxu/fxuSingle.c
index 6e90a2a2..b1cc2e63 100644
--- a/src/opt/fxu/fxuSingle.c
+++ b/src/opt/fxu/fxuSingle.c
@@ -19,6 +19,9 @@
 #include "fxuInt.h"
 #include "vec.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -100,8 +103,8 @@ void Fxu_MatrixComputeSingles( Fxu_Matrix * p, int fUse0, int nSingleMax )
     for ( i = 0; i < Vec_PtrSize(vSingles); i += 3 )
     {
         Fxu_MatrixAddSingle( p, 
-            Vec_PtrEntry(vSingles,i), 
-            Vec_PtrEntry(vSingles,i+1), 
+            (Fxu_Var *)Vec_PtrEntry(vSingles,i), 
+            (Fxu_Var *)Vec_PtrEntry(vSingles,i+1), 
             (int)(ABC_PTRUINT_T)Vec_PtrEntry(vSingles,i+2) );
     }
     Vec_PtrFree( vSingles );
@@ -282,3 +285,5 @@ int Fxu_SingleCountCoincidence( Fxu_Matrix * p, Fxu_Var * pVar1, Fxu_Var * pVar2
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/fxu/fxuUpdate.c b/src/opt/fxu/fxuUpdate.c
index cdbe313d..74939896 100644
--- a/src/opt/fxu/fxuUpdate.c
+++ b/src/opt/fxu/fxuUpdate.c
@@ -18,6 +18,9 @@
 
 #include "fxuInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -292,7 +295,7 @@ void Fxu_UpdateDoublePairs( Fxu_Matrix * p, Fxu_Double * pDouble, Fxu_Var * pVar
     {
         // get the pair
 //        pPair = p->pPairsTemp[i];
-        pPair = p->vPairs->pArray[i];
+        pPair = (Fxu_Pair *)p->vPairs->pArray[i];
         // out of the two cubes, select the one which comes earlier
         pCubeUse = Fxu_PairMinCube( pPair );
         pCubeRem = Fxu_PairMaxCube( pPair );
@@ -344,7 +347,7 @@ void Fxu_UpdateMatrixDoubleCreateCubes( Fxu_Matrix * p, Fxu_Cube * pCube1, Fxu_C
         if ( pLit1 && pLit2 )
         {
             if ( pLit1->iVar == pLit2->iVar )
-            { // skip the cube ABC_FREE part
+            { // skip the cube free part
                 pLit1 = pLit1->pHNext;
                 pLit2 = pLit2->pHNext;
                 nBase++;
@@ -804,3 +807,5 @@ void Fxu_UpdateAddNewSingles( Fxu_Matrix * p, Fxu_Var * pVar )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
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
+
diff --git a/src/opt/mfs/mfs.h b/src/opt/mfs/mfs.h
index 8b49345e..02fcc21b 100644
--- a/src/opt/mfs/mfs.h
+++ b/src/opt/mfs/mfs.h
@@ -21,6 +21,7 @@
 #ifndef __MFS_H__
 #define __MFS_H__
 
+
 ////////////////////////////////////////////////////////////////////////
 ///                          INCLUDES                                ///
 ////////////////////////////////////////////////////////////////////////
@@ -29,9 +30,10 @@
 ///                         PARAMETERS                               ///
 ////////////////////////////////////////////////////////////////////////
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+
+
+ABC_NAMESPACE_HEADER_START
+
 
 ////////////////////////////////////////////////////////////////////////
 ///                         BASIC TYPES                              ///
@@ -73,9 +75,11 @@ extern void        Abc_NtkMfsParsDefault( Mfs_Par_t * pPars );
 extern int         Abc_NtkMfs( Abc_Ntk_t * pNtk, Mfs_Par_t * pPars );
 
  
-#ifdef __cplusplus
-}
-#endif
+
+
+ABC_NAMESPACE_HEADER_END
+
+
 
 #endif
 
diff --git a/src/opt/mfs/mfsCore.c b/src/opt/mfs/mfsCore.c
index c598a19b..bda95d55 100644
--- a/src/opt/mfs/mfsCore.c
+++ b/src/opt/mfs/mfsCore.c
@@ -20,6 +20,9 @@
 
 #include "mfsInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -148,7 +151,7 @@ int Abc_NtkMfsPowerResubNode( Mfs_Man_t * p, Abc_Obj_t * pNode )
 }
 */
 
-Abc_NtkMfsPowerResub( Mfs_Man_t * p, Mfs_Par_t * pPars)
+void Abc_NtkMfsPowerResub( Mfs_Man_t * p, Mfs_Par_t * pPars)
 {
     int i, k;
     Abc_Obj_t *pFanin, *pNode;
@@ -326,7 +329,7 @@ clk = clock();
 p->timeCnf += clock() - clk;
     // create the SAT problem
 clk = clock();
-    p->pSat = Cnf_DataWriteIntoSolver( p->pCnf, 1, 0 );
+    p->pSat = (sat_solver *)Cnf_DataWriteIntoSolver( p->pCnf, 1, 0 );
     if ( p->pSat && p->pPars->fOneHotness )
         Abc_NtkAddOneHotness( p );
     if ( p->pSat == NULL )
@@ -344,8 +347,8 @@ p->timeSat += clock() - clk;
     // minimize the local function of the node using bi-decomposition
     assert( p->nFanins == Abc_ObjFaninNum(pNode) );
     dProb = p->pPars->fPower? ((float *)p->vProbs->pArray)[pNode->Id] : -1.0;
-    pObj = Abc_NodeIfNodeResyn( p->pManDec, pNode->pNtk->pManFunc, pNode->pData, p->nFanins, p->vTruth, p->uCare, dProb );
-    nGain = Hop_DagSize(pNode->pData) - Hop_DagSize(pObj);
+    pObj = Abc_NodeIfNodeResyn( p->pManDec, (Hop_Man_t *)pNode->pNtk->pManFunc, (Hop_Obj_t *)pNode->pData, p->nFanins, p->vTruth, p->uCare, dProb );
+    nGain = Hop_DagSize((Hop_Obj_t *)pNode->pData) - Hop_DagSize(pObj);
     if ( nGain >= 0 )
     {
         p->nNodesDec++;
@@ -432,12 +435,12 @@ int Abc_NtkMfs( Abc_Ntk_t * pNtk, Mfs_Par_t * pPars )
     if ( pNtk->pExcare )
     {
         Abc_Ntk_t * pTemp;
-        if ( Abc_NtkPiNum(pNtk->pExcare) != Abc_NtkCiNum(pNtk) )
+        if ( Abc_NtkPiNum((Abc_Ntk_t *)pNtk->pExcare) != Abc_NtkCiNum(pNtk) )
             printf( "The PI count of careset (%d) and logic network (%d) differ. Careset is not used.\n",
-                Abc_NtkPiNum(pNtk->pExcare), Abc_NtkCiNum(pNtk) );
+                Abc_NtkPiNum((Abc_Ntk_t *)pNtk->pExcare), Abc_NtkCiNum(pNtk) );
         else
         {
-            pTemp = Abc_NtkStrash( pNtk->pExcare, 0, 0, 0 );
+            pTemp = Abc_NtkStrash( (Abc_Ntk_t *)pNtk->pExcare, 0, 0, 0 );
             p->pCare = Abc_NtkToDar( pTemp, 0, 0 );
             Abc_NtkDelete( pTemp );
             p->vSuppsInv = Aig_ManSupportsInverse( p->pCare );
@@ -513,7 +516,7 @@ int Abc_NtkMfs( Abc_Ntk_t * pNtk, Mfs_Par_t * pPars )
             p->nTotConfLevel = 0;
             p->nTimeOutsLevel = 0;
             clk2 = clock();
-            Vec_PtrForEachEntry( vNodes, pObj, i )
+            Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
             {
                 if ( p->pPars->nDepthMax && (int)pObj->Level > p->pPars->nDepthMax )
                     break;
@@ -584,3 +587,5 @@ int Abc_NtkMfs( Abc_Ntk_t * pNtk, Mfs_Par_t * pPars )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/mfs/mfsCore_.c b/src/opt/mfs/mfsCore_.c
index 66b497f6..69f64ae5 100644
--- a/src/opt/mfs/mfsCore_.c
+++ b/src/opt/mfs/mfsCore_.c
@@ -20,6 +20,9 @@
 
 #include "mfsInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -386,3 +389,5 @@ int Abc_NtkMfs( Abc_Ntk_t * pNtk, Mfs_Par_t * pPars )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/mfs/mfsDiv.c b/src/opt/mfs/mfsDiv.c
index f5a07d31..1473580e 100644
--- a/src/opt/mfs/mfsDiv.c
+++ b/src/opt/mfs/mfsDiv.c
@@ -20,6 +20,9 @@
 
 #include "mfsInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -201,7 +204,7 @@ Vec_Ptr_t * Abc_MfsComputeDivisors( Mfs_Man_t * p, Abc_Obj_t * pNode, int nLevDi
 
     // count the number of PIs
     nTrueSupp = 0;
-    Vec_PtrForEachEntry( vCone, pObj, k )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vCone, pObj, k )
         nTrueSupp += Abc_ObjIsCi(pObj);
 //    printf( "%d(%d) ", Vec_PtrSize(p->vSupp), m );
 
@@ -221,7 +224,7 @@ Vec_Ptr_t * Abc_MfsComputeDivisors( Mfs_Man_t * p, Abc_Obj_t * pNode, int nLevDi
 
     // start collecting the divisors
     vDivs = Vec_PtrAlloc( p->pPars->nDivMax );
-    Vec_PtrForEachEntry( vCone, pObj, k )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vCone, pObj, k )
     {
         if ( !Abc_NodeIsTravIdPrevious(pObj) )
             continue;
@@ -235,7 +238,7 @@ Vec_Ptr_t * Abc_MfsComputeDivisors( Mfs_Man_t * p, Abc_Obj_t * pNode, int nLevDi
 
     // explore the fanouts of already collected divisors
     if ( Vec_PtrSize(vDivs) < p->pPars->nDivMax )
-    Vec_PtrForEachEntry( vDivs, pObj, k )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vDivs, pObj, k )
     {
         // consider fanouts of this node
         Abc_ObjForEachFanout( pObj, pFanout, f )
@@ -262,7 +265,7 @@ Vec_Ptr_t * Abc_MfsComputeDivisors( Mfs_Man_t * p, Abc_Obj_t * pNode, int nLevDi
             if ( m < Abc_ObjFaninNum(pFanout) )
                 continue;
             // make sure this divisor in not among the nodes
-//            Vec_PtrForEachEntry( p->vNodes, pFanin, m )
+//            Vec_PtrForEachEntry( Abc_Obj_t *, p->vNodes, pFanin, m )
 //                assert( pFanout != pFanin );
             // add the node to the divisors
             Vec_PtrPush( vDivs, pFanout );
@@ -278,7 +281,7 @@ Vec_Ptr_t * Abc_MfsComputeDivisors( Mfs_Man_t * p, Abc_Obj_t * pNode, int nLevDi
     }
 
     // sort the divisors by level in the increasing order
-    Vec_PtrSort( vDivs, Abc_NodeCompareLevelsIncrease );
+    Vec_PtrSort( vDivs, (int (*)(void))Abc_NodeCompareLevelsIncrease );
 
     // add the fanins of the node
     Abc_ObjForEachFanin( pNode, pFanin, k )
@@ -286,7 +289,7 @@ Vec_Ptr_t * Abc_MfsComputeDivisors( Mfs_Man_t * p, Abc_Obj_t * pNode, int nLevDi
 
 /*
     printf( "Node level = %d.  ", Abc_ObjLevel(p->pNode) );
-    Vec_PtrForEachEntryStart( vDivs, pObj, k, Vec_PtrSize(vDivs)-p->nDivsPlus )
+    Vec_PtrForEachEntryStart( Abc_Obj_t *, vDivs, pObj, k, Vec_PtrSize(vDivs)-p->nDivsPlus )
         printf( "%d ", Abc_ObjLevel(pObj) );
     printf( "\n" );
 */
@@ -301,3 +304,5 @@ Vec_Ptr_t * Abc_MfsComputeDivisors( Mfs_Man_t * p, Abc_Obj_t * pNode, int nLevDi
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/mfs/mfsGia.c b/src/opt/mfs/mfsGia.c
new file mode 100644
index 00000000..016b4ae2
--- /dev/null
+++ b/src/opt/mfs/mfsGia.c
@@ -0,0 +1,299 @@
+/**CFile****************************************************************
+
+  FileName    [mfsGia.c]
+
+  SystemName  [ABC: Logic synthesis and verification system.]
+
+  PackageName [The good old minimization with complete don't-cares.]
+
+  Synopsis    [Experimental code based on the new AIG package.]
+
+  Author      [Alan Mishchenko]
+
+  Affiliation [UC Berkeley]
+
+  Date        [Ver. 1.0. Started - July 29, 2009.]
+
+  Revision    [$Id: mfsGia.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+ 
+#include "mfsInt.h"
+#include "giaAig.h"
+
+ABC_NAMESPACE_IMPL_START
+
+
+////////////////////////////////////////////////////////////////////////
+///                        DECLARATIONS                              ///
+////////////////////////////////////////////////////////////////////////
+
+static inline int Gia_ObjChild0Copy( Aig_Obj_t * pObj )  { return Gia_LitNotCond( Aig_ObjFanin0(pObj)->iData, Aig_ObjFaninC0(pObj) ); }
+static inline int Gia_ObjChild1Copy( Aig_Obj_t * pObj )  { return Gia_LitNotCond( Aig_ObjFanin1(pObj)->iData, Aig_ObjFaninC1(pObj) ); }
+
+// r i10_if6.blif;  ps; mfs -v
+// r pj1_if6.blif;  ps; mfs -v
+// r x/01_if6.blif; ps; mfs -v
+
+////////////////////////////////////////////////////////////////////////
+///                     FUNCTION DEFINITIONS                         ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+  Synopsis    [Derives the resubstitution miter as an GIA.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+ 
+***********************************************************************/
+Gia_Man_t * Gia_ManCreateResubMiter( Aig_Man_t * p )
+{
+    Gia_Man_t * pNew;//, * pTemp;
+    Aig_Obj_t * pObj;
+    int i, * pOuts0, * pOuts1;
+    Aig_ManSetPioNumbers( p );
+    // create the new manager
+    pNew = Gia_ManStart( Aig_ManObjNum(p) );
+    pNew->pName = Gia_UtilStrsav( p->pName );
+    Gia_ManHashAlloc( pNew );
+    // create the objects
+    pOuts0 = ABC_ALLOC( int, Aig_ManPoNum(p) );
+    Aig_ManForEachObj( p, pObj, i )
+    {
+        if ( Aig_ObjIsAnd(pObj) )
+            pObj->iData = Gia_ManHashAnd( pNew, Gia_ObjChild0Copy(pObj), Gia_ObjChild1Copy(pObj) );
+        else if ( Aig_ObjIsPi(pObj) )
+            pObj->iData = Gia_ManAppendCi( pNew );
+        else if ( Aig_ObjIsPo(pObj) )
+            pOuts0[ Aig_ObjPioNum(pObj) ] = Gia_ObjChild0Copy(pObj);
+        else if ( Aig_ObjIsConst1(pObj) )
+            pObj->iData = 1;
+        else
+            assert( 0 );
+    }
+    // create the objects
+    pOuts1 = ABC_ALLOC( int, Aig_ManPoNum(p) );
+    Aig_ManForEachObj( p, pObj, i )
+    {
+        if ( Aig_ObjIsAnd(pObj) )
+            pObj->iData = Gia_ManHashAnd( pNew, Gia_ObjChild0Copy(pObj), Gia_ObjChild1Copy(pObj) );
+        else if ( Aig_ObjIsPi(pObj) )
+            pObj->iData = Gia_ManAppendCi( pNew );
+        else if ( Aig_ObjIsPo(pObj) )
+            pOuts1[ Aig_ObjPioNum(pObj) ] = Gia_ObjChild0Copy(pObj);
+        else if ( Aig_ObjIsConst1(pObj) )
+            pObj->iData = 1;
+        else
+            assert( 0 );
+    }
+    // add the outputs
+    Gia_ManAppendCo( pNew, pOuts0[0] );
+    Gia_ManAppendCo( pNew, pOuts1[0] );
+    Gia_ManAppendCo( pNew, pOuts0[1] );
+    Gia_ManAppendCo( pNew, Gia_LitNot(pOuts1[1]) );
+    for ( i = 2; i < Aig_ManPoNum(p); i++ )
+        Gia_ManAppendCo( pNew, Gia_LitNot( Gia_ManHashXor(pNew, pOuts0[i], pOuts1[i]) ) );
+    Gia_ManHashStop( pNew );
+    ABC_FREE( pOuts0 );
+    ABC_FREE( pOuts1 );
+//    pNew = Gia_ManCleanup( pTemp = pNew );
+//    Gia_ManStop( pTemp );
+    return pNew;
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Abc_NtkMfsConstructGia( Mfs_Man_t * p )
+{
+    int nBTLimit = 500;
+    // prepare AIG
+    assert( p->pGia == NULL );
+    p->pGia = Gia_ManCreateResubMiter( p->pAigWin );
+    // prepare AIG
+    Gia_ManCreateRefs( p->pGia );
+    Gia_ManCleanMark0( p->pGia );
+    Gia_ManCleanMark1( p->pGia );
+    Gia_ManFillValue ( p->pGia ); // maps nodes into trail ids
+    Gia_ManCleanPhase( p->pGia ); 
+    // prepare solver
+    p->pTas = Tas_ManAlloc( p->pGia, nBTLimit );
+    p->vCex = Tas_ReadModel( p->pTas );
+    p->vGiaLits = Vec_PtrAlloc( 100 );
+}
+
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Abc_NtkMfsDeconstructGia( Mfs_Man_t * p )
+{
+    assert( p->pGia != NULL );
+    Gia_ManStop( p->pGia ); p->pGia = NULL;
+    Tas_ManStop( p->pTas ); p->pTas = NULL;
+    Vec_PtrFree( p->vGiaLits );
+}
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+void Abc_NtkMfsResimulate( Gia_Man_t * p, Vec_Int_t * vCex )
+{
+    Gia_Obj_t * pObj;
+    int i, Entry;
+//    Gia_ManCleanMark1( p );
+    Gia_ManConst0(p)->fMark1 = 0;
+    Gia_ManForEachCi( p, pObj, i )
+        pObj->fMark1 = 0;
+//        pObj->fMark1 = Gia_ManRandom(0);
+    Vec_IntForEachEntry( vCex, Entry, i )
+    {
+        pObj = Gia_ManCi( p, Gia_Lit2Var(Entry) );
+        pObj->fMark1 = !Gia_LitIsCompl(Entry);
+    }
+    Gia_ManForEachAnd( p, pObj, i )
+        pObj->fMark1 = (Gia_ObjFanin0(pObj)->fMark1 ^ Gia_ObjFaninC0(pObj)) & 
+                       (Gia_ObjFanin1(pObj)->fMark1 ^ Gia_ObjFaninC1(pObj));
+    Gia_ManForEachCo( p, pObj, i )
+        pObj->fMark1 =  Gia_ObjFanin0(pObj)->fMark1 ^ Gia_ObjFaninC0(pObj);
+}
+
+
+
+
+/**Function*************************************************************
+
+  Synopsis    []
+
+  Description []
+
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Abc_NtkMfsTryResubOnceGia( Mfs_Man_t * p, int * pCands, int nCands )
+{
+    int fVeryVerbose = 0;
+    int fUseGia = 1;
+    unsigned * pData;
+    int i, iVar, status, iOut, clk = clock();
+    p->nSatCalls++;
+//    return -1;
+    assert( p->pGia != NULL );
+    assert( p->pTas != NULL );
+    // convert to literals
+    Vec_PtrClear( p->vGiaLits );
+    // create the first four literals
+    Vec_PtrPush( p->vGiaLits, Gia_ObjChild0(Gia_ManPo(p->pGia, 0)) );
+    Vec_PtrPush( p->vGiaLits, Gia_ObjChild0(Gia_ManPo(p->pGia, 1)) );
+    Vec_PtrPush( p->vGiaLits, Gia_ObjChild0(Gia_ManPo(p->pGia, 2)) );
+    Vec_PtrPush( p->vGiaLits, Gia_ObjChild0(Gia_ManPo(p->pGia, 3)) );
+    for ( i = 0; i < nCands; i++ )
+    {
+        // get the output number
+        iOut = Gia_Lit2Var(pCands[i]) - 2 * p->pCnf->nVars;
+        // write the literal
+        Vec_PtrPush( p->vGiaLits, Gia_ObjChild0(Gia_ManPo(p->pGia, 4 + iOut)) );
+    }
+    // perform SAT solving
+    status = Tas_ManSolveArray( p->pTas, p->vGiaLits );
+    if ( status == -1 )
+    {
+        p->nTimeOuts++;
+        if ( fVeryVerbose )
+        printf( "t" );
+//        p->nSatUndec++;
+//        p->nConfUndec += p->Pars.nBTThis;
+//        Cec_ManSatAddToStore( vCexStore, NULL, i ); // timeout
+//        p->timeSatUndec += clock() - clk;
+    }
+    else if ( status == 1 )
+    {
+        if ( fVeryVerbose )
+        printf( "u" );
+//        p->nSatUnsat++;
+//        p->nConfUnsat += p->Pars.nBTThis;
+//        p->timeSatUnsat += clock() - clk;
+    }
+    else
+    {
+        p->nSatCexes++;
+        if ( fVeryVerbose )
+        printf( "s" );
+//        p->nSatSat++;
+//        p->nConfSat += p->Pars.nBTThis;
+//        Gia_SatVerifyPattern( pAig, pRoot, vCex, vVisit );
+//        Cec_ManSatAddToStore( vCexStore, vCex, i );
+//        p->timeSatSat += clock() - clk;
+
+        // resimulate the counter-example
+        Abc_NtkMfsResimulate( p->pGia, Tas_ReadModel(p->pTas) );
+   
+        if ( fUseGia )
+        {
+/*
+            int Val0 = Gia_ManPo(p->pGia, 0)->fMark1;
+            int Val1 = Gia_ManPo(p->pGia, 1)->fMark1;
+            int Val2 = Gia_ManPo(p->pGia, 2)->fMark1;
+            int Val3 = Gia_ManPo(p->pGia, 3)->fMark1;
+            assert( Val0 == 1 );
+            assert( Val1 == 1 );
+            assert( Val2 == 1 );
+            assert( Val3 == 1 );
+*/
+            // store the counter-example
+            Vec_IntForEachEntry( p->vProjVars, iVar, i )
+            {
+                pData = (unsigned *)Vec_PtrEntry( p->vDivCexes, i );
+                iOut = iVar - 2 * p->pCnf->nVars;
+//                if ( !Gia_ManPo( p->pGia, 4 + iOut )->fMark1 ) // remove 0s!!!
+                if ( Gia_ManPo( p->pGia, 4 + iOut )->fMark1 ) // remove 0s!!!  - rememeber complemented attribute
+                {
+                    assert( Aig_InfoHasBit(pData, p->nCexes) );
+                    Aig_InfoXorBit( pData, p->nCexes );
+                }
+            }
+            p->nCexes++;
+        }
+
+    }
+    return status;
+}
+
+
+////////////////////////////////////////////////////////////////////////
+///                       END OF FILE                                ///
+////////////////////////////////////////////////////////////////////////
+
+
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/mfs/mfsInt.h b/src/opt/mfs/mfsInt.h
index 8adffd44..5611afa0 100644
--- a/src/opt/mfs/mfsInt.h
+++ b/src/opt/mfs/mfsInt.h
@@ -21,6 +21,7 @@
 #ifndef __MFS_INT_H__
 #define __MFS_INT_H__
 
+
 ////////////////////////////////////////////////////////////////////////
 ///                          INCLUDES                                ///
 ////////////////////////////////////////////////////////////////////////
@@ -38,9 +39,10 @@
 ///                         PARAMETERS                               ///
 ////////////////////////////////////////////////////////////////////////
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+
+
+ABC_NAMESPACE_HEADER_START
+
 
 #define MFS_FANIN_MAX   12
 
@@ -168,9 +170,11 @@ extern void             Abc_NtkMfsConstructGia( Mfs_Man_t * p );
 extern void             Abc_NtkMfsDeconstructGia( Mfs_Man_t * p );
 extern int              Abc_NtkMfsTryResubOnceGia( Mfs_Man_t * p, int * pCands, int nCands );
 
-#ifdef __cplusplus
-}
-#endif
+
+
+ABC_NAMESPACE_HEADER_END
+
+
 
 #endif
 
diff --git a/src/opt/mfs/mfsInter.c b/src/opt/mfs/mfsInter.c
index 9cacd021..1b3f2415 100644
--- a/src/opt/mfs/mfsInter.c
+++ b/src/opt/mfs/mfsInter.c
@@ -21,6 +21,9 @@
 #include "mfsInt.h"
 #include "kit.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -94,7 +97,7 @@ sat_solver * Abc_MfsCreateSolverResub( Mfs_Man_t * p, int * pCands, int nCands,
 
     // collect the outputs of the divisors
     Vec_IntClear( p->vProjVars );
-    Vec_PtrForEachEntryStart( p->pAigWin->vPos, pObjPo, i, Aig_ManPoNum(p->pAigWin) - Vec_PtrSize(p->vDivs) )
+    Vec_PtrForEachEntryStart( Aig_Obj_t *, p->pAigWin->vPos, pObjPo, i, Aig_ManPoNum(p->pAigWin) - Vec_PtrSize(p->vDivs) )
     {
         assert( p->pCnf->pVarNums[pObjPo->Id] >= 0 );
         Vec_IntPush( p->vProjVars, p->pCnf->pVarNums[pObjPo->Id] );
@@ -246,7 +249,7 @@ unsigned * Abc_NtkMfsInterplateTruth( Mfs_Man_t * p, int * pCands, int nCands, i
         return NULL;
     }
     // get the learned clauses
-    pCnf = sat_solver_store_release( pSat );
+    pCnf = (Sto_Man_t *)sat_solver_store_release( pSat );
     sat_solver_delete( pSat );
 
     // set the global variables
@@ -349,7 +352,7 @@ Hop_Obj_t * Abc_NtkMfsInterplate( Mfs_Man_t * p, int * pCands, int nCands )
 //printf( "%d\n", pSat->stats.conflicts );
 //    ABC_PRT( "S", clock() - clk );
     // get the learned clauses
-    pCnf = sat_solver_store_release( pSat );
+    pCnf = (Sto_Man_t *)sat_solver_store_release( pSat );
     sat_solver_delete( pSat );
 
     // set the global variables
@@ -369,7 +372,7 @@ Hop_Obj_t * Abc_NtkMfsInterplate( Mfs_Man_t * p, int * pCands, int nCands )
 
     // transform interpolant into AIG
     pGraph = Kit_TruthToGraph( puTruth, nFanins, p->vMem );
-    pFunc = Kit_GraphToHop( p->pNtk->pManFunc, pGraph );
+    pFunc = Kit_GraphToHop( (Hop_Man_t *)p->pNtk->pManFunc, pGraph );
     Kit_GraphFree( pGraph );
     return pFunc;
 }
@@ -379,3 +382,5 @@ Hop_Obj_t * Abc_NtkMfsInterplate( Mfs_Man_t * p, int * pCands, int nCands )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/mfs/mfsMan.c b/src/opt/mfs/mfsMan.c
index 96a43368..74889c45 100644
--- a/src/opt/mfs/mfsMan.c
+++ b/src/opt/mfs/mfsMan.c
@@ -20,6 +20,9 @@
 
 #include "mfsInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -210,3 +213,5 @@ void Mfs_ManStop( Mfs_Man_t * p )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/mfs/mfsResub.c b/src/opt/mfs/mfsResub.c
index 49ce6901..38004089 100644
--- a/src/opt/mfs/mfsResub.c
+++ b/src/opt/mfs/mfsResub.c
@@ -20,6 +20,9 @@
 
 #include "mfsInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -46,7 +49,7 @@ void Abc_NtkMfsUpdateNetwork( Mfs_Man_t * p, Abc_Obj_t * pObj, Vec_Ptr_t * vFani
     // create the new node
     pObjNew = Abc_NtkCreateNode( pObj->pNtk );
     pObjNew->pData = pFunc;
-    Vec_PtrForEachEntry( vFanins, pFanin, k )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vFanins, pFanin, k )
         Abc_ObjAddFanin( pObjNew, pFanin );
     // replace the old node by the new node
 //printf( "Replacing node " ); Abc_ObjPrint( stdout, pObj );
@@ -136,7 +139,7 @@ p->timeGia += clock() - clk;
     // store the counter-example
     Vec_IntForEachEntry( p->vProjVars, iVar, i )
     {
-        pData = Vec_PtrEntry( p->vDivCexes, i );
+        pData = (unsigned *)Vec_PtrEntry( p->vDivCexes, i );
         if ( !sat_solver_var_value( p->pSat, iVar ) ) // remove 0s!!!
         {
             assert( Aig_InfoHasBit(pData, p->nCexes) );
@@ -238,7 +241,7 @@ p->timeInt += clock() - clk;
             printf( "%3d: %2d ", p->nCexes, iVar );
             for ( i = 0; i < Vec_PtrSize(p->vDivs); i++ )
             {
-                pData = Vec_PtrEntry( p->vDivCexes, i );
+                pData = (unsigned *)Vec_PtrEntry( p->vDivCexes, i );
                 printf( "%d", Aig_InfoHasBit(pData, p->nCexes-1) );
             }
             printf( "\n" );
@@ -251,12 +254,12 @@ p->timeInt += clock() - clk;
         {
             if ( p->pPars->fPower )
             {
-                Abc_Obj_t * pDiv = Vec_PtrEntry(p->vDivs, iVar);
+                Abc_Obj_t * pDiv = (Abc_Obj_t *)Vec_PtrEntry(p->vDivs, iVar);
                 // only accept the divisor if it is "cool"
                 if ( Abc_MfsObjProb(p, pDiv) >= 0.15 )
                     continue;
             }
-            pData  = Vec_PtrEntry( p->vDivCexes, iVar );
+            pData  = (unsigned *)Vec_PtrEntry( p->vDivCexes, iVar );
             for ( w = 0; w < nWords; w++ )
                 if ( pData[w] != ~0 )
                     break;
@@ -383,7 +386,7 @@ p->timeInt += clock() - clk;
             printf( "%3d: %2d %2d ", p->nCexes, iVar, iVar2 );
             for ( i = 0; i < Vec_PtrSize(p->vDivs); i++ )
             {
-                pData = Vec_PtrEntry( p->vDivCexes, i );
+                pData = (unsigned *)Vec_PtrEntry( p->vDivCexes, i );
                 printf( "%d", Aig_InfoHasBit(pData, p->nCexes-1) );
             }
             printf( "\n" );
@@ -395,11 +398,11 @@ p->timeInt += clock() - clk;
         fBreak = 0;
         for ( iVar = 1; iVar < Vec_PtrSize(p->vDivs)-Abc_ObjFaninNum(pNode); iVar++ )
         {
-            pData  = Vec_PtrEntry( p->vDivCexes, iVar );
+            pData  = (unsigned *)Vec_PtrEntry( p->vDivCexes, iVar );
 #if 1  // sjang
             if ( p->pPars->fPower )
             {
-                Abc_Obj_t * pDiv = Vec_PtrEntry(p->vDivs, iVar);
+                Abc_Obj_t * pDiv = (Abc_Obj_t *)Vec_PtrEntry(p->vDivs, iVar);
                 // only accept the divisor if it is "cool"
                 if ( Abc_MfsObjProb(p, pDiv) >= 0.12 )
                     continue;
@@ -407,11 +410,11 @@ p->timeInt += clock() - clk;
 #endif
             for ( iVar2 = 0; iVar2 < iVar; iVar2++ )
             {
-                pData2 = Vec_PtrEntry( p->vDivCexes, iVar2 );
+                pData2 = (unsigned *)Vec_PtrEntry( p->vDivCexes, iVar2 );
 #if 1 // sjang
                 if ( p->pPars->fPower )
                 {
-                    Abc_Obj_t * pDiv = Vec_PtrEntry(p->vDivs, iVar2);
+                    Abc_Obj_t * pDiv = (Abc_Obj_t *)Vec_PtrEntry(p->vDivs, iVar2);
                     // only accept the divisor if it is "cool"
                     if ( Abc_MfsObjProb(p, pDiv) >= 0.12 )
                         continue;
@@ -607,3 +610,5 @@ int Abc_NtkMfsResubNode2( Mfs_Man_t * p, Abc_Obj_t * pNode )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/mfs/mfsResub_.c b/src/opt/mfs/mfsResub_.c
index 47600b30..bca1285d 100644
--- a/src/opt/mfs/mfsResub_.c
+++ b/src/opt/mfs/mfsResub_.c
@@ -20,6 +20,9 @@
 
 #include "mfsInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -558,3 +561,5 @@ int Abc_NtkMfsResubNode2( Mfs_Man_t * p, Abc_Obj_t * pNode )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/mfs/mfsSat.c b/src/opt/mfs/mfsSat.c
index eab80c53..c5806f2a 100644
--- a/src/opt/mfs/mfsSat.c
+++ b/src/opt/mfs/mfsSat.c
@@ -20,6 +20,9 @@
 
 #include "mfsInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -95,7 +98,7 @@ int Abc_NtkMfsSolveSat( Mfs_Man_t * p, Abc_Obj_t * pNode )
     int RetValue, i;
     // collect projection variables
     Vec_IntClear( p->vProjVars );
-    Vec_PtrForEachEntryStart( p->pAigWin->vPos, pObjPo, i, Aig_ManPoNum(p->pAigWin) - Abc_ObjFaninNum(pNode) )
+    Vec_PtrForEachEntryStart( Aig_Obj_t *, p->pAigWin->vPos, pObjPo, i, Aig_ManPoNum(p->pAigWin) - Abc_ObjFaninNum(pNode) )
     {
         assert( p->pCnf->pVarNums[pObjPo->Id] >= 0 );
         Vec_IntPush( p->vProjVars, p->pCnf->pVarNums[pObjPo->Id] );
@@ -175,3 +178,5 @@ int Abc_NtkAddOneHotness( Mfs_Man_t * p )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/mfs/mfsStrash.c b/src/opt/mfs/mfsStrash.c
index 7e6c25da..a5c7b987 100644
--- a/src/opt/mfs/mfsStrash.c
+++ b/src/opt/mfs/mfsStrash.c
@@ -20,6 +20,8 @@
 
 #include "mfsInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -47,7 +49,7 @@ void Abc_MfsConvertAigToHop_rec( Aig_Obj_t * pObj, Hop_Man_t * pHop )
     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(pObj->pData) );
+    assert( !Hop_IsComplement((Hop_Obj_t *)pObj->pData) );
 }
 
 /**Function*************************************************************
@@ -77,7 +79,7 @@ Hop_Obj_t * Abc_MfsConvertAigToHop( Aig_Man_t * pMan, Hop_Man_t * pHop )
         pObj->pData = Hop_IthVar( pHop, i );
     // construct the AIG
     Abc_MfsConvertAigToHop_rec( Aig_ObjFanin0(pRoot), pHop );
-    return Hop_NotCond( Aig_ObjFanin0(pRoot)->pData, Aig_ObjFaninC0(pRoot) );
+    return Hop_NotCond( (Hop_Obj_t *)Aig_ObjFanin0(pRoot)->pData, Aig_ObjFaninC0(pRoot) );
 }
 
 // should be called as follows:   pNodeNew->pData = Abc_MfsConvertAigToHop( pAigManInterpol, pNodeNew->pNtk->pManFunc );
@@ -123,8 +125,8 @@ void Abc_MfsConvertHopToAig( Abc_Obj_t * pObjOld, Aig_Man_t * pMan )
     Abc_Obj_t * pFanin;
     int i;
     // get the local AIG
-    pHopMan = pObjOld->pNtk->pManFunc;
-    pRoot = pObjOld->pData;
+    pHopMan = (Hop_Man_t *)pObjOld->pNtk->pManFunc;
+    pRoot = (Hop_Obj_t *)pObjOld->pData;
     // check the case of a constant
     if ( Hop_ObjIsConst1( Hop_Regular(pRoot) ) )
     {
@@ -138,7 +140,7 @@ void Abc_MfsConvertHopToAig( Abc_Obj_t * pObjOld, Aig_Man_t * pMan )
         Hop_ManPi(pHopMan, i)->pData = pFanin->pCopy;
     // construct the AIG
     Abc_MfsConvertHopToAig_rec( Hop_Regular(pRoot), pMan );
-    pObjOld->pCopy = (Abc_Obj_t *)Aig_NotCond( Hop_Regular(pRoot)->pData, Hop_IsComplement(pRoot) );  
+    pObjOld->pCopy = (Abc_Obj_t *)Aig_NotCond( (Aig_Obj_t *)Hop_Regular(pRoot)->pData, Hop_IsComplement(pRoot) );  
     Hop_ConeUnmark_rec( Hop_Regular(pRoot) );
 
     // assign the fanin nodes
@@ -146,7 +148,7 @@ void Abc_MfsConvertHopToAig( Abc_Obj_t * pObjOld, Aig_Man_t * pMan )
         Hop_ManPi(pHopMan, i)->pData = pFanin->pNext;
     // construct the AIG
     Abc_MfsConvertHopToAig_rec( Hop_Regular(pRoot), pMan );
-    pObjOld->pNext = (Abc_Obj_t *)Aig_NotCond( Hop_Regular(pRoot)->pData, Hop_IsComplement(pRoot) );  
+    pObjOld->pNext = (Abc_Obj_t *)Aig_NotCond( (Aig_Obj_t *)Hop_Regular(pRoot)->pData, Hop_IsComplement(pRoot) );  
     Hop_ConeUnmark_rec( Hop_Regular(pRoot) );
 }
 
@@ -167,11 +169,11 @@ Aig_Obj_t * Abc_NtkConstructAig_rec( Mfs_Man_t * p, Abc_Obj_t * pNode, Aig_Man_t
     Abc_Obj_t * pObj;
     int i;
     // assign AIG nodes to the leaves
-    Vec_PtrForEachEntry( p->vSupp, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, p->vSupp, pObj, i )
         pObj->pCopy = pObj->pNext = (Abc_Obj_t *)Aig_ObjCreatePi( pMan );
     // strash intermediate nodes
     Abc_NtkIncrementTravId( pNode->pNtk );
-    Vec_PtrForEachEntry( p->vNodes, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, p->vNodes, pObj, i )
     {
         Abc_MfsConvertHopToAig( pObj, pMan );
         if ( pObj == pNode )
@@ -179,7 +181,7 @@ Aig_Obj_t * Abc_NtkConstructAig_rec( Mfs_Man_t * p, Abc_Obj_t * pNode, Aig_Man_t
     }
     // create the observability condition
     pRoot = Aig_ManConst0(pMan);
-    Vec_PtrForEachEntry( p->vRoots, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, p->vRoots, pObj, i )
     {
         pExor = Aig_Exor( pMan, (Aig_Obj_t *)pObj->pCopy, (Aig_Obj_t *)pObj->pNext );
         pRoot = Aig_Or( pMan, pRoot, pExor );
@@ -202,19 +204,19 @@ Aig_Obj_t * Abc_NtkConstructCare_rec( Aig_Man_t * pCare, Aig_Obj_t * pObj, Aig_M
 {
     Aig_Obj_t * pObj0, * pObj1;
     if ( Aig_ObjIsTravIdCurrent( pCare, pObj ) )
-        return pObj->pData;
+        return (Aig_Obj_t *)pObj->pData;
     Aig_ObjSetTravIdCurrent( pCare, pObj );
     if ( Aig_ObjIsPi(pObj) )
-        return pObj->pData = NULL;
+        return (Aig_Obj_t *)(pObj->pData = NULL);
     pObj0 = Abc_NtkConstructCare_rec( pCare, Aig_ObjFanin0(pObj), pMan );
     if ( pObj0 == NULL )
-        return pObj->pData = NULL;
+        return (Aig_Obj_t *)(pObj->pData = NULL);
     pObj1 = Abc_NtkConstructCare_rec( pCare, Aig_ObjFanin1(pObj), pMan );
     if ( pObj1 == NULL )
-        return pObj->pData = NULL;
+        return (Aig_Obj_t *)(pObj->pData = NULL);
     pObj0 = Aig_NotCond( pObj0, Aig_ObjFaninC0(pObj) );
     pObj1 = Aig_NotCond( pObj1, Aig_ObjFaninC1(pObj) );
-    return pObj->pData = Aig_And( pMan, pObj0, pObj1 );
+    return (Aig_Obj_t *)(pObj->pData = Aig_And( pMan, pObj0, pObj1 ));
 }
 
 /**Function*************************************************************
@@ -245,16 +247,16 @@ Aig_Man_t * Abc_NtkConstructAig( Mfs_Man_t * p, Abc_Obj_t * pNode )
     {
         // mark the care set
         Aig_ManIncrementTravId( p->pCare );
-        Vec_PtrForEachEntry( p->vSupp, pFanin, i )
+        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( p->vSupp, pFanin, i )
+        Vec_PtrForEachEntry( Abc_Obj_t *, p->vSupp, pFanin, i )
         {
-            vOuts = Vec_PtrEntry( p->vSuppsInv, (int)(ABC_PTRUINT_T)pFanin->pData );
+            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 );
@@ -290,7 +292,7 @@ Aig_Man_t * Abc_NtkConstructAig( Mfs_Man_t * p, Abc_Obj_t * pNode )
         pObjAig = (Aig_Obj_t *)pNode->pCopy;
         Aig_ObjCreatePo( pMan, pObjAig );
         // construct the divisors
-        Vec_PtrForEachEntry( p->vDivs, pFanin, i )
+        Vec_PtrForEachEntry( Abc_Obj_t *, p->vDivs, pFanin, i )
         {
             pObjAig = (Aig_Obj_t *)pFanin->pCopy;
             Aig_ObjCreatePo( pMan, pObjAig );
@@ -332,7 +334,7 @@ Aig_Man_t * Abc_NtkAigForConstraints( Mfs_Man_t * p, Abc_Obj_t * pNode )
     pMan = Aig_ManStart( 1000 );
     // mark the care set
     Aig_ManIncrementTravId( p->pCare );
-    Vec_PtrForEachEntry( p->vSupp, pFanin, i )
+    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 );
@@ -340,9 +342,9 @@ Aig_Man_t * Abc_NtkAigForConstraints( Mfs_Man_t * p, Abc_Obj_t * pNode )
     }
     // construct the constraints
     pObjRoot = Aig_ManConst1(pMan);
-    Vec_PtrForEachEntry( p->vSupp, pFanin, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, p->vSupp, pFanin, i )
     {
-        vOuts = Vec_PtrEntry( p->vSuppsInv, (int)(ABC_PTRUINT_T)pFanin->pData );
+        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 );
@@ -363,8 +365,13 @@ Aig_Man_t * Abc_NtkAigForConstraints( Mfs_Man_t * p, Abc_Obj_t * pNode )
     return pMan;
 }
 
+ABC_NAMESPACE_IMPL_END
+
 #include "fra.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 /**Function*************************************************************
 
   Synopsis    [Compute the ratio of don't-cares.]
@@ -395,3 +402,5 @@ double Abc_NtkConstraintRatio( Mfs_Man_t * p, Abc_Obj_t * pNode )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/mfs/mfsWin.c b/src/opt/mfs/mfsWin.c
index e3e5e24e..2ed996be 100644
--- a/src/opt/mfs/mfsWin.c
+++ b/src/opt/mfs/mfsWin.c
@@ -20,6 +20,9 @@
 
 #include "mfsInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -110,3 +113,5 @@ Vec_Ptr_t * Abc_MfsComputeRoots( Abc_Obj_t * pNode, int nWinTfoMax, int nFanoutL
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/mfs/mfs_.c b/src/opt/mfs/mfs_.c
index 32caf7ff..2682fa42 100644
--- a/src/opt/mfs/mfs_.c
+++ b/src/opt/mfs/mfs_.c
@@ -20,6 +20,9 @@
 
 #include "mfsInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -45,3 +48,5 @@
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/res/res.h b/src/opt/res/res.h
index 88d985a3..bd328d54 100644
--- a/src/opt/res/res.h
+++ b/src/opt/res/res.h
@@ -21,6 +21,7 @@
 #ifndef __RES_H__
 #define __RES_H__
 
+
 ////////////////////////////////////////////////////////////////////////
 ///                          INCLUDES                                ///
 ////////////////////////////////////////////////////////////////////////
@@ -29,9 +30,10 @@
 ///                         PARAMETERS                               ///
 ////////////////////////////////////////////////////////////////////////
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+
+
+ABC_NAMESPACE_HEADER_START
+
 
 ////////////////////////////////////////////////////////////////////////
 ///                         BASIC TYPES                              ///
@@ -63,9 +65,11 @@ struct Res_Par_t_
 extern int        Abc_NtkResynthesize( Abc_Ntk_t * pNtk, Res_Par_t * pPars );
 
 
-#ifdef __cplusplus
-}
-#endif
+
+
+ABC_NAMESPACE_HEADER_END
+
+
 
 #endif
 
diff --git a/src/opt/res/resCore.c b/src/opt/res/resCore.c
index cce3b48a..c27b3874 100644
--- a/src/opt/res/resCore.c
+++ b/src/opt/res/resCore.c
@@ -23,6 +23,9 @@
 #include "kit.h"
 #include "satStore.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -187,7 +190,7 @@ void Res_UpdateNetwork( Abc_Obj_t * pObj, Vec_Ptr_t * vFanins, Hop_Obj_t * pFunc
     // create the new node
     pObjNew = Abc_NtkCreateNode( pObj->pNtk );
     pObjNew->pData = pFunc;
-    Vec_PtrForEachEntry( vFanins, pFanin, k )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vFanins, pFanin, k )
         Abc_ObjAddFanin( pObjNew, pFanin );
     // replace the old node by the new node
 //printf( "Replacing node " ); Abc_ObjPrint( stdout, pObj );
@@ -316,8 +319,8 @@ p->timeSim += clock() - clk;
         {
             p->nConstsUsed++;
 
-            pFunc = p->pSim->fConst1? Hop_ManConst1(pNtk->pManFunc) : Hop_ManConst0(pNtk->pManFunc);
-            vFanins = Vec_VecEntry( p->vResubsW, 0 );
+            pFunc = p->pSim->fConst1? Hop_ManConst1((Hop_Man_t *)pNtk->pManFunc) : Hop_ManConst0((Hop_Man_t *)pNtk->pManFunc);
+            vFanins = (Vec_Ptr_t *)Vec_VecEntry( p->vResubsW, 0 );
             Vec_PtrClear( vFanins );
             Res_UpdateNetwork( pObj, vFanins, pFunc, p->vLevels );
             continue;
@@ -349,7 +352,7 @@ p->timeCand += clock() - clk;
             // solve the SAT problem and get clauses
 clk = clock();
             if ( p->pCnf ) Sto_ManFree( p->pCnf );
-            p->pCnf = Res_SatProveUnsat( p->pAig, vFanins );
+            p->pCnf = (Sto_Man_t *)Res_SatProveUnsat( p->pAig, vFanins );
             if ( p->pCnf == NULL )
             {
 p->timeSatSat += clock() - clk;
@@ -381,12 +384,12 @@ p->timeInt += clock() - clk;
             pGraph = Kit_TruthToGraph( puTruth, nFanins, p->vMem );
 
             // derive the AIG for the decomposition tree
-            pFunc = Kit_GraphToHop( pNtk->pManFunc, pGraph );
+            pFunc = Kit_GraphToHop( (Hop_Man_t *)pNtk->pManFunc, pGraph );
             Kit_GraphFree( pGraph );
 
             // update the network
 clk = clock();
-            Res_UpdateNetwork( pObj, Vec_VecEntry(p->vResubsW, k), pFunc, p->vLevels );
+            Res_UpdateNetwork( pObj, (Vec_Ptr_t *)Vec_VecEntry(p->vResubsW, k), pFunc, p->vLevels );
 p->timeUpd += clock() - clk;
             break;
         }
@@ -420,3 +423,5 @@ s_ResynTime += clock() - clkTotal;
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/res/resDivs.c b/src/opt/res/resDivs.c
index f6c8a801..6d9ffd9f 100644
--- a/src/opt/res/resDivs.c
+++ b/src/opt/res/resDivs.c
@@ -21,6 +21,9 @@
 #include "abc.h"
 #include "resInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -70,7 +73,7 @@ void Res_WinDivisors( Res_Win_t * p, int nLevDivMax )
 
     // start collecting the divisors
     Vec_PtrClear( p->vDivs );
-    Vec_PtrForEachEntry( p->vLeaves, pObj, k )
+    Vec_PtrForEachEntry( Abc_Obj_t *, p->vLeaves, pObj, k )
     {
         assert( (int)pObj->Level >= p->nLevLeafMin ); 
         if ( !Abc_NodeIsTravIdPrevious(pObj) )
@@ -80,7 +83,7 @@ void Res_WinDivisors( Res_Win_t * p, int nLevDivMax )
         Vec_PtrPush( p->vDivs, pObj );
     }
     // add the internal nodes to the data structure
-    Vec_PtrForEachEntry( p->vNodes, pObj, k )
+    Vec_PtrForEachEntry( Abc_Obj_t *, p->vNodes, pObj, k )
     {
         if ( !Abc_NodeIsTravIdPrevious(pObj) )
             continue;
@@ -91,7 +94,7 @@ void Res_WinDivisors( Res_Win_t * p, int nLevDivMax )
 
     // explore the fanouts of already collected divisors
     p->nDivsPlus = 0;
-    Vec_PtrForEachEntry( p->vDivs, pObj, k )
+    Vec_PtrForEachEntry( Abc_Obj_t *, p->vDivs, pObj, k )
     {
         // consider fanouts of this node
         Abc_ObjForEachFanout( pObj, pFanout, f )
@@ -126,7 +129,7 @@ void Res_WinDivisors( Res_Win_t * p, int nLevDivMax )
     }
 /*
     printf( "Node level = %d.  ", Abc_ObjLevel(p->pNode) );
-    Vec_PtrForEachEntryStart( p->vDivs, pObj, k, Vec_PtrSize(p->vDivs)-p->nDivsPlus )
+    Vec_PtrForEachEntryStart( Abc_Obj_t *, p->vDivs, pObj, k, Vec_PtrSize(p->vDivs)-p->nDivsPlus )
         printf( "%d ", Abc_ObjLevel(pObj) );
     printf( "\n" );
 */
@@ -173,7 +176,7 @@ void Res_WinMarkTfi( Res_Win_t * p )
     Abc_Obj_t * pObj;
     int i;
     // mark the leaves
-    Vec_PtrForEachEntry( p->vLeaves, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, p->vLeaves, pObj, i )
         Abc_NodeSetTravIdCurrent( pObj );
     // start from the node
     Res_WinMarkTfi_rec( p, p->pNode );
@@ -283,3 +286,5 @@ int Res_WinVisitMffc( Abc_Obj_t * pNode )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/res/resFilter.c b/src/opt/res/resFilter.c
index f2ca41d3..b9d62dd8 100644
--- a/src/opt/res/resFilter.c
+++ b/src/opt/res/resFilter.c
@@ -21,6 +21,9 @@
 #include "abc.h"
 #include "resInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -50,7 +53,7 @@ int Res_FilterCandidates( Res_Win_t * pWin, Abc_Ntk_t * pAig, Res_Sim_t * pSim,
     int Counter, RetValue, i, i2, d, d2, iDiv, iDiv2, k;
 
     // check that the info the node is one
-    pInfo = Vec_PtrEntry( pSim->vOuts, 1 );
+    pInfo = (unsigned *)Vec_PtrEntry( pSim->vOuts, 1 );
     RetValue = Abc_InfoIsOne( pInfo, pSim->nWordsOut );
     if ( RetValue == 0 )
     {
@@ -109,7 +112,7 @@ int Res_FilterCandidates( Res_Win_t * pWin, Abc_Ntk_t * pAig, Res_Sim_t * pSim,
         // go over the set of divisors
         for ( d = Abc_ObjFaninNum(pWin->pNode) + 2; d < Abc_NtkPoNum(pAig); d++ )
         {
-            pInfoDiv = Vec_PtrEntry( pSim->vOuts, d );
+            pInfoDiv = (unsigned *)Vec_PtrEntry( pSim->vOuts, d );
             iDiv = d - (Abc_ObjFaninNum(pWin->pNode) + 2);
             if ( !Abc_InfoIsOrOne( pInfo, pInfoDiv, pSim->nWordsOut ) )
                 continue;
@@ -147,12 +150,12 @@ int Res_FilterCandidates( Res_Win_t * pWin, Abc_Ntk_t * pAig, Res_Sim_t * pSim,
             // go over the set of divisors
             for ( d = Abc_ObjFaninNum(pWin->pNode) + 2; d < Abc_NtkPoNum(pAig); d++ )
             {
-                pInfoDiv = Vec_PtrEntry( pSim->vOuts, d );
+                pInfoDiv = (unsigned *)Vec_PtrEntry( pSim->vOuts, d );
                 iDiv = d - (Abc_ObjFaninNum(pWin->pNode) + 2);
                 // go through the second divisor
                 for ( d2 = d + 1; d2 < Abc_NtkPoNum(pAig); d2++ )
                 {
-                    pInfoDiv2 = Vec_PtrEntry( pSim->vOuts, d2 );
+                    pInfoDiv2 = (unsigned *)Vec_PtrEntry( pSim->vOuts, d2 );
                     iDiv2 = d2 - (Abc_ObjFaninNum(pWin->pNode) + 2);
                     if ( !Abc_InfoIsOrOne3( pInfo, pInfoDiv, pInfoDiv2, pSim->nWordsOut ) )
                         continue;
@@ -194,7 +197,7 @@ int Res_FilterCandidates( Res_Win_t * pWin, Abc_Ntk_t * pAig, Res_Sim_t * pSim,
                 // go over the set of divisors
                 for ( d = Abc_ObjFaninNum(pWin->pNode) + 2; d < Abc_NtkPoNum(pAig); d++ )
                 {
-                    pInfoDiv = Vec_PtrEntry( pSim->vOuts, d );
+                    pInfoDiv = (unsigned *)Vec_PtrEntry( pSim->vOuts, d );
                     iDiv = d - (Abc_ObjFaninNum(pWin->pNode) + 2);
                     if ( !Abc_InfoIsOrOne( pInfo, pInfoDiv, pSim->nWordsOut ) )
                         continue;
@@ -242,7 +245,7 @@ int Res_FilterCandidatesArea( Res_Win_t * pWin, Abc_Ntk_t * pAig, Res_Sim_t * pS
     int Counter, RetValue, d, d2, k, iDiv, iDiv2, iBest;
 
     // check that the info the node is one
-    pInfo = Vec_PtrEntry( pSim->vOuts, 1 );
+    pInfo = (unsigned *)Vec_PtrEntry( pSim->vOuts, 1 );
     RetValue = Abc_InfoIsOne( pInfo, pSim->nWordsOut );
     if ( RetValue == 0 )
     {
@@ -294,7 +297,7 @@ int Res_FilterCandidatesArea( Res_Win_t * pWin, Abc_Ntk_t * pAig, Res_Sim_t * pS
     // go through the divisors
     for ( d = Abc_ObjFaninNum(pWin->pNode) + 2; d < Abc_NtkPoNum(pAig); d++ )
     {
-        pInfoDiv = Vec_PtrEntry( pSim->vOuts, d );
+        pInfoDiv = (unsigned *)Vec_PtrEntry( pSim->vOuts, d );
         iDiv = d - (Abc_ObjFaninNum(pWin->pNode) + 2);
         if ( !Abc_InfoIsOrOne( pInfo, pInfoDiv, pSim->nWordsOut ) )
             continue;
@@ -327,12 +330,12 @@ int Res_FilterCandidatesArea( Res_Win_t * pWin, Abc_Ntk_t * pAig, Res_Sim_t * pS
     // try to find the node pairs
     for ( d = Abc_ObjFaninNum(pWin->pNode) + 2; d < Abc_NtkPoNum(pAig); d++ )
     {
-        pInfoDiv = Vec_PtrEntry( pSim->vOuts, d );
+        pInfoDiv = (unsigned *)Vec_PtrEntry( pSim->vOuts, d );
         iDiv = d - (Abc_ObjFaninNum(pWin->pNode) + 2);
         // go through the second divisor
         for ( d2 = d + 1; d2 < Abc_NtkPoNum(pAig); d2++ )
         {
-            pInfoDiv2 = Vec_PtrEntry( pSim->vOuts, d2 );
+            pInfoDiv2 = (unsigned *)Vec_PtrEntry( pSim->vOuts, d2 );
             iDiv2 = d2 - (Abc_ObjFaninNum(pWin->pNode) + 2);
 
             if ( !Abc_InfoIsOrOne3( pInfo, pInfoDiv, pInfoDiv2, pSim->nWordsOut ) )
@@ -382,12 +385,12 @@ unsigned * Res_FilterCollectFaninInfo( Res_Win_t * pWin, Res_Sim_t * pSim, unsig
     Abc_Obj_t * pFanin;
     unsigned * pInfo;
     int i;
-    pInfo = Vec_PtrEntry( pSim->vOuts, 0 );
+    pInfo = (unsigned *)Vec_PtrEntry( pSim->vOuts, 0 );
     Abc_InfoClear( pInfo, pSim->nWordsOut );
     Abc_ObjForEachFanin( pWin->pNode, pFanin, i )
     {
         if ( uMask & (1 << i) )
-            Abc_InfoOr( pInfo, Vec_PtrEntry(pSim->vOuts, 2+i), pSim->nWordsOut );
+            Abc_InfoOr( pInfo, (unsigned *)Vec_PtrEntry(pSim->vOuts, 2+i), pSim->nWordsOut );
     }
     return pInfo;
 }
@@ -432,3 +435,5 @@ int Res_FilterCriticalFanin( Abc_Obj_t * pNode )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/res/resInt.h b/src/opt/res/resInt.h
index 172b5369..ae238359 100644
--- a/src/opt/res/resInt.h
+++ b/src/opt/res/resInt.h
@@ -21,6 +21,7 @@
 #ifndef __RES_INT_H__
 #define __RES_INT_H__
 
+
 ////////////////////////////////////////////////////////////////////////
 ///                          INCLUDES                                ///
 ////////////////////////////////////////////////////////////////////////
@@ -31,9 +32,10 @@
 ///                         PARAMETERS                               ///
 ////////////////////////////////////////////////////////////////////////
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+
+
+ABC_NAMESPACE_HEADER_START
+
 
 ////////////////////////////////////////////////////////////////////////
 ///                         BASIC TYPES                              ///
@@ -125,9 +127,11 @@ extern int           Res_WinIsTrivial( Res_Win_t * p );
 extern int           Res_WinCompute( Abc_Obj_t * pNode, int nWinTfiMax, int nWinTfoMax, Res_Win_t * p );
 
 
-#ifdef __cplusplus
-}
-#endif
+
+
+ABC_NAMESPACE_HEADER_END
+
+
 
 #endif
 
diff --git a/src/opt/res/resSat.c b/src/opt/res/resSat.c
index d5983942..a17f92fa 100644
--- a/src/opt/res/resSat.c
+++ b/src/opt/res/resSat.c
@@ -23,6 +23,9 @@
 #include "hop.h"
 #include "satSolver.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -55,7 +58,7 @@ void * Res_SatProveUnsat( Abc_Ntk_t * pAig, Vec_Ptr_t * vFanins )
     int i, nNodes, status;
 
     // make sure fanins contain POs of the AIG
-    pObj = Vec_PtrEntry( vFanins, 0 );
+    pObj = (Abc_Obj_t *)Vec_PtrEntry( vFanins, 0 );
     assert( pObj->pNtk == pAig && Abc_ObjIsPo(pObj) );
 
     // collect reachable nodes
@@ -63,13 +66,13 @@ void * Res_SatProveUnsat( Abc_Ntk_t * pAig, Vec_Ptr_t * vFanins )
 
     // assign unique numbers to each node
     nNodes = 0;
-    Abc_AigConst1(pAig)->pCopy = (void *)(ABC_PTRUINT_T)nNodes++;
+    Abc_AigConst1(pAig)->pCopy = (Abc_Obj_t *)(ABC_PTRUINT_T)nNodes++;
     Abc_NtkForEachPi( pAig, pObj, i )
-        pObj->pCopy = (void *)(ABC_PTRUINT_T)nNodes++;
-    Vec_PtrForEachEntry( vNodes, pObj, i )
-        pObj->pCopy = (void *)(ABC_PTRUINT_T)nNodes++;
-    Vec_PtrForEachEntry( vFanins, pObj, i ) // useful POs
-        pObj->pCopy = (void *)(ABC_PTRUINT_T)nNodes++;
+        pObj->pCopy = (Abc_Obj_t *)(ABC_PTRUINT_T)nNodes++;
+    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
+        pObj->pCopy = (Abc_Obj_t *)(ABC_PTRUINT_T)nNodes++;
+    Vec_PtrForEachEntry( Abc_Obj_t *, vFanins, pObj, i ) // useful POs
+        pObj->pCopy = (Abc_Obj_t *)(ABC_PTRUINT_T)nNodes++;
 
     // start the solver
     pSat = sat_solver_new();
@@ -78,28 +81,28 @@ void * Res_SatProveUnsat( Abc_Ntk_t * pAig, Vec_Ptr_t * vFanins )
     // add clause for the constant node
     Res_SatAddConst1( pSat, (int)(ABC_PTRUINT_T)Abc_AigConst1(pAig)->pCopy, 0 );
     // add clauses for AND gates
-    Vec_PtrForEachEntry( vNodes, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
         Res_SatAddAnd( pSat, (int)(ABC_PTRUINT_T)pObj->pCopy, 
             (int)(ABC_PTRUINT_T)Abc_ObjFanin0(pObj)->pCopy, (int)(ABC_PTRUINT_T)Abc_ObjFanin1(pObj)->pCopy, Abc_ObjFaninC0(pObj), Abc_ObjFaninC1(pObj) );
     Vec_PtrFree( vNodes );
     // add clauses for POs
-    Vec_PtrForEachEntry( vFanins, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vFanins, pObj, i )
         Res_SatAddEqual( pSat, (int)(ABC_PTRUINT_T)pObj->pCopy, 
             (int)(ABC_PTRUINT_T)Abc_ObjFanin0(pObj)->pCopy, Abc_ObjFaninC0(pObj) );
     // add trivial clauses
-    pObj = Vec_PtrEntry(vFanins, 0);
+    pObj = (Abc_Obj_t *)Vec_PtrEntry(vFanins, 0);
     Res_SatAddConst1( pSat, (int)(ABC_PTRUINT_T)pObj->pCopy, 0 ); // care-set
-    pObj = Vec_PtrEntry(vFanins, 1);
+    pObj = (Abc_Obj_t *)Vec_PtrEntry(vFanins, 1);
     Res_SatAddConst1( pSat, (int)(ABC_PTRUINT_T)pObj->pCopy, 0 ); // on-set
 
     // bookmark the clauses of A
     sat_solver_store_mark_clauses_a( pSat );
 
     // duplicate the clauses
-    pObj = Vec_PtrEntry(vFanins, 1);
+    pObj = (Abc_Obj_t *)Vec_PtrEntry(vFanins, 1);
     Sat_SolverDoubleClauses( pSat, (int)(ABC_PTRUINT_T)pObj->pCopy );
     // add the equality constraints
-    Vec_PtrForEachEntryStart( vFanins, pObj, i, 2 )
+    Vec_PtrForEachEntryStart( Abc_Obj_t *, vFanins, pObj, i, 2 )
         Res_SatAddEqual( pSat, (int)(ABC_PTRUINT_T)pObj->pCopy, ((int)(ABC_PTRUINT_T)pObj->pCopy) + nNodes, 0 );
 
     // bookmark the roots
@@ -155,13 +158,13 @@ void * Res_SatSimulateConstr( Abc_Ntk_t * pAig, int fOnSet )
 
     // assign unique numbers to each node
     nNodes = 0;
-    Abc_AigConst1(pAig)->pCopy = (void *)(ABC_PTRUINT_T)nNodes++;
+    Abc_AigConst1(pAig)->pCopy = (Abc_Obj_t *)(ABC_PTRUINT_T)nNodes++;
     Abc_NtkForEachPi( pAig, pObj, i )
-        pObj->pCopy = (void *)(ABC_PTRUINT_T)nNodes++;
-    Vec_PtrForEachEntry( vNodes, pObj, i )
-        pObj->pCopy = (void *)(ABC_PTRUINT_T)nNodes++;
-    Vec_PtrForEachEntry( vFanins, pObj, i ) // useful POs
-        pObj->pCopy = (void *)(ABC_PTRUINT_T)nNodes++;
+        pObj->pCopy = (Abc_Obj_t *)(ABC_PTRUINT_T)nNodes++;
+    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
+        pObj->pCopy = (Abc_Obj_t *)(ABC_PTRUINT_T)nNodes++;
+    Vec_PtrForEachEntry( Abc_Obj_t *, vFanins, pObj, i ) // useful POs
+        pObj->pCopy = (Abc_Obj_t *)(ABC_PTRUINT_T)nNodes++;
 
     // start the solver
     pSat = sat_solver_new();
@@ -169,7 +172,7 @@ void * Res_SatSimulateConstr( Abc_Ntk_t * pAig, int fOnSet )
     // add clause for the constant node
     Res_SatAddConst1( pSat, (int)(ABC_PTRUINT_T)Abc_AigConst1(pAig)->pCopy, 0 );
     // add clauses for AND gates
-    Vec_PtrForEachEntry( vNodes, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
         Res_SatAddAnd( pSat, (int)(ABC_PTRUINT_T)pObj->pCopy, 
             (int)(ABC_PTRUINT_T)Abc_ObjFanin0(pObj)->pCopy, (int)(ABC_PTRUINT_T)Abc_ObjFanin1(pObj)->pCopy, Abc_ObjFaninC0(pObj), Abc_ObjFaninC1(pObj) );
     Vec_PtrFree( vNodes );
@@ -232,7 +235,7 @@ int Res_SatSimulate( Res_Sim_t * p, int nPatsLimit, int fOnSet )
     assert( iPat < nPatsLimit );
 
     // derive the SAT solver
-    pSat = Res_SatSimulateConstr( p->pAig, fOnSet );
+    pSat = (sat_solver *)Res_SatSimulateConstr( p->pAig, fOnSet );
     pSat->fSkipSimplify = 1;
     status = sat_solver_simplify( pSat );
     if ( status == 0 )
@@ -278,7 +281,7 @@ int Res_SatSimulate( Res_Sim_t * p, int nPatsLimit, int fOnSet )
                 Var = (int)(ABC_PTRUINT_T)Abc_NtkPi(p->pAig,i)->pCopy;
                 value = (int)(pSat->model.ptr[Var] == l_True);
                 if ( value )
-                    Abc_InfoSetBit( Vec_PtrEntry(vPats, i), k );
+                    Abc_InfoSetBit( (unsigned *)Vec_PtrEntry(vPats, i), k );
                 Lit = toLitCond( Var, value );
                 Vec_IntPush( vLits, Lit );
 //                printf( "%d", value );
@@ -406,3 +409,5 @@ int Res_SatAddAnd( sat_solver * pSat, int iVar, int iVar0, int iVar1, int fCompl
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/res/resSim.c b/src/opt/res/resSim.c
index 59b2b6ea..560acc43 100644
--- a/src/opt/res/resSim.c
+++ b/src/opt/res/resSim.c
@@ -21,6 +21,9 @@
 #include "abc.h"
 #include "resInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -102,8 +105,8 @@ void Res_SimAdjust( Res_Sim_t * p, Abc_Ntk_t * pAig, int nTruePis )
         p->vOuts = Vec_PtrAllocSimInfo( Abc_NtkPoNum(pAig), p->nWordsOut );
     }
     // clean storage info for patterns
-    Abc_InfoClear( Vec_PtrEntry(p->vPats0,0), p->nWords * nTruePis );
-    Abc_InfoClear( Vec_PtrEntry(p->vPats1,0), p->nWords * nTruePis );
+    Abc_InfoClear( (unsigned *)Vec_PtrEntry(p->vPats0,0), p->nWords * nTruePis );
+    Abc_InfoClear( (unsigned *)Vec_PtrEntry(p->vPats1,0), p->nWords * nTruePis );
     p->nPats0 = 0;
     p->nPats1 = 0;
     p->fConst0 = 0;
@@ -175,7 +178,7 @@ void Res_SimSetRandomBytes( Res_Sim_t * p )
     int i;
     Abc_NtkForEachPi( p->pAig, pObj, i )
     {
-        pInfo = Vec_PtrEntry( p->vPats, pObj->Id );
+        pInfo = (unsigned *)Vec_PtrEntry( p->vPats, pObj->Id );
         if ( i < p->nTruePis )
             Abc_InfoRandomBytes( pInfo, p->nWordsIn );
         else
@@ -220,7 +223,7 @@ void Res_SimSetDerivedBytes( Res_Sim_t * p, int fUseWalk )
     {
         if ( i == p->nTruePis )
             break;
-        Abc_InfoRandomBytes( Vec_PtrEntry(p->vPats, pObj->Id), nPats/4 );
+        Abc_InfoRandomBytes( (unsigned *)Vec_PtrEntry(p->vPats, pObj->Id), nPats/4 );
     }
 
     // set special patterns
@@ -283,7 +286,7 @@ void Res_SimSetDerivedBytes( Res_Sim_t * p, int fUseWalk )
                     if ( i == p->nTruePis )
                         break;
                     pInfo = (unsigned char *)Vec_PtrEntry( p->vPats, pObj->Id );
-                    if ( (i == k) ^ Abc_InfoHasBit( Vec_PtrEntry(vPatsSource[z], i), s ) )
+                    if ( (i == k) ^ Abc_InfoHasBit( (unsigned *)Vec_PtrEntry(vPatsSource[z], i), s ) )
                     {
                         pInfo[nPats] = 0xff;
 //                        if ( s == 0 )
@@ -347,8 +350,8 @@ void Res_SimSetGiven( Res_Sim_t * p, Vec_Ptr_t * vInfo )
     {
         if ( i == p->nTruePis )
             break;
-        pInfo = Vec_PtrEntry( p->vPats, pObj->Id );
-        pInfo2 = Vec_PtrEntry( vInfo, i );
+        pInfo = (unsigned *)Vec_PtrEntry( p->vPats, pObj->Id );
+        pInfo2 = (unsigned *)Vec_PtrEntry( vInfo, i );
         for ( w = 0; w < p->nWords; w++ )
             pInfo[w] = pInfo2[w];
     }
@@ -371,9 +374,9 @@ void Res_SimPerformOne( Abc_Obj_t * pNode, Vec_Ptr_t * vSimInfo, int nSimWords )
     int k, fComp1, fComp2;
     // simulate the internal nodes
     assert( Abc_ObjIsNode(pNode) );
-    pInfo  = Vec_PtrEntry(vSimInfo, pNode->Id);
-    pInfo1 = Vec_PtrEntry(vSimInfo, Abc_ObjFaninId0(pNode));
-    pInfo2 = Vec_PtrEntry(vSimInfo, Abc_ObjFaninId1(pNode));
+    pInfo  = (unsigned *)Vec_PtrEntry(vSimInfo, pNode->Id);
+    pInfo1 = (unsigned *)Vec_PtrEntry(vSimInfo, Abc_ObjFaninId0(pNode));
+    pInfo2 = (unsigned *)Vec_PtrEntry(vSimInfo, Abc_ObjFaninId1(pNode));
     fComp1 = Abc_ObjFaninC0(pNode);
     fComp2 = Abc_ObjFaninC1(pNode);
     if ( fComp1 && fComp2 )
@@ -407,8 +410,8 @@ void Res_SimTransferOne( Abc_Obj_t * pNode, Vec_Ptr_t * vSimInfo, int nSimWords
     int k, fComp1;
     // simulate the internal nodes
     assert( Abc_ObjIsCo(pNode) );
-    pInfo  = Vec_PtrEntry(vSimInfo, pNode->Id);
-    pInfo1 = Vec_PtrEntry(vSimInfo, Abc_ObjFaninId0(pNode));
+    pInfo  = (unsigned *)Vec_PtrEntry(vSimInfo, pNode->Id);
+    pInfo1 = (unsigned *)Vec_PtrEntry(vSimInfo, Abc_ObjFaninId0(pNode));
     fComp1 = Abc_ObjFaninC0(pNode);
     if ( fComp1 )
         for ( k = 0; k < nSimWords; k++ )
@@ -433,7 +436,7 @@ void Res_SimPerformRound( Res_Sim_t * p, int nWords )
 {
     Abc_Obj_t * pObj;
     int i;
-    Abc_InfoFill( Vec_PtrEntry(p->vPats,0), nWords );
+    Abc_InfoFill( (unsigned *)Vec_PtrEntry(p->vPats,0), nWords );
     Abc_AigForEachAnd( p->pAig, pObj, i )
         Res_SimPerformOne( pObj, p->vPats, nWords );
     Abc_NtkForEachPo( p->pAig, pObj, i )
@@ -460,14 +463,14 @@ void Res_SimPadSimInfo( Vec_Ptr_t * vPats, int nPats, int nWords )
     // pad the first word
     if ( nPats < 8 * sizeof(unsigned) )
     {
-        Vec_PtrForEachEntry( vPats, pInfo, i )
+        Vec_PtrForEachEntry( unsigned *, vPats, pInfo, i )
             if ( pInfo[0] & 1 )
                 pInfo[0] |= ((~0) << nPats);
         nPats = 8 * sizeof(unsigned);
     }
     // pad the empty words
     iWords = nPats / (8 * sizeof(unsigned));
-    Vec_PtrForEachEntry( vPats, pInfo, i )
+    Vec_PtrForEachEntry( unsigned *, vPats, pInfo, i )
     {
         for ( w = iWords; w < nWords; w++ )
             pInfo[w] = pInfo[0];
@@ -492,8 +495,8 @@ void Res_SimDeriveInfoReplicate( Res_Sim_t * p )
     int i, j, w;
     Abc_NtkForEachPo( p->pAig, pObj, i )
     {
-        pInfo = Vec_PtrEntry( p->vPats, pObj->Id );
-        pInfo2 = Vec_PtrEntry( p->vOuts, i );
+        pInfo = (unsigned *)Vec_PtrEntry( p->vPats, pObj->Id );
+        pInfo2 = (unsigned *)Vec_PtrEntry( p->vOuts, i );
         for ( j = 0; j < p->nPats; j++ )
             for ( w = 0; w < p->nWords; w++ )
                 *pInfo2++ = pInfo[w];
@@ -518,8 +521,8 @@ void Res_SimDeriveInfoComplement( Res_Sim_t * p )
     int i, j, w;
     Abc_NtkForEachPo( p->pAig, pObj, i )
     {
-        pInfo = Vec_PtrEntry( p->vPats, pObj->Id );
-        pInfo2 = Vec_PtrEntry( p->vOuts, i );
+        pInfo = (unsigned *)Vec_PtrEntry( p->vPats, pObj->Id );
+        pInfo2 = (unsigned *)Vec_PtrEntry( p->vOuts, i );
         for ( j = 0; j < p->nPats; j++, pInfo2 += p->nWords )
             if ( Abc_InfoHasBit( pInfo, j ) )
                 for ( w = 0; w < p->nWords; w++ )
@@ -545,7 +548,7 @@ void Res_SimPrintOutPatterns( Res_Sim_t * p, Abc_Ntk_t * pAig )
     int i;
     Abc_NtkForEachPo( pAig, pObj, i )
     {
-        pInfo2 = Vec_PtrEntry( p->vOuts, i );
+        pInfo2 = (unsigned *)Vec_PtrEntry( p->vOuts, i );
         Extra_PrintBinary( stdout, pInfo2, p->nPatsOut );
         printf( "\n" );
     }
@@ -565,7 +568,7 @@ void Res_SimPrintOutPatterns( Res_Sim_t * p, Abc_Ntk_t * pAig )
 void Res_SimPrintNodePatterns( Res_Sim_t * p, Abc_Ntk_t * pAig )
 {
     unsigned * pInfo;
-    pInfo = Vec_PtrEntry( p->vPats, Abc_NtkPo(p->pAig, 1)->Id );
+    pInfo = (unsigned *)Vec_PtrEntry( p->vPats, Abc_NtkPo(p->pAig, 1)->Id );
     Extra_PrintBinary( stdout, pInfo, p->nPats );
     printf( "\n" );
 }
@@ -643,7 +646,7 @@ void Res_SimCollectPatterns( Res_Sim_t * p, int fVerbose )
                 pInfo = (unsigned char *)Vec_PtrEntry( p->vPats, pObj->Id );
                 assert( pInfo[i] == 0 || pInfo[i] == 0xff );
                 if ( pInfo[i] )
-                    Abc_InfoSetBit( Vec_PtrEntry(p->vPats0, j), p->nPats0 );
+                    Abc_InfoSetBit( (unsigned *)Vec_PtrEntry(p->vPats0, j), p->nPats0 );
             }
             p->nPats0++;
         }
@@ -658,7 +661,7 @@ void Res_SimCollectPatterns( Res_Sim_t * p, int fVerbose )
                 pInfo = (unsigned char *)Vec_PtrEntry( p->vPats, pObj->Id );
                 assert( pInfo[i] == 0 || pInfo[i] == 0xff );
                 if ( pInfo[i] )
-                    Abc_InfoSetBit( Vec_PtrEntry(p->vPats1, j), p->nPats1 );
+                    Abc_InfoSetBit( (unsigned *)Vec_PtrEntry(p->vPats1, j), p->nPats1 );
             }
             p->nPats1++;
         }
@@ -696,20 +699,20 @@ int Res_SimVerifyValue( Res_Sim_t * p, int fOnSet )
             break;
         if ( fOnSet )
         {
-            pInfo2 = Vec_PtrEntry( p->vPats1, i );
+            pInfo2 = (unsigned *)Vec_PtrEntry( p->vPats1, i );
             value = Abc_InfoHasBit( pInfo2, p->nPats1 - 1 );
         }
         else
         {
-            pInfo2 = Vec_PtrEntry( p->vPats0, i );
+            pInfo2 = (unsigned *)Vec_PtrEntry( p->vPats0, i );
             value = Abc_InfoHasBit( pInfo2, p->nPats0 - 1 );
         }
-        pInfo = Vec_PtrEntry( p->vPats, pObj->Id );
+        pInfo = (unsigned *)Vec_PtrEntry( p->vPats, pObj->Id );
         pInfo[0] = value ? ~0 : 0;
     }
     Res_SimPerformRound( p, 1 );
     pObj = Abc_NtkPo( p->pAig, 1 );
-    pInfo = Vec_PtrEntry( p->vPats, pObj->Id );
+    pInfo = (unsigned *)Vec_PtrEntry( p->vPats, pObj->Id );
     assert( pInfo[0] == 0 || pInfo[0] == ~0 );
     return pInfo[0] > 0;
 }
@@ -788,3 +791,5 @@ int Res_SimPrepare( Res_Sim_t * p, Abc_Ntk_t * pAig, int nTruePis, int fVerbose
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/res/resSim_old.c b/src/opt/res/resSim_old.c
index 23ce29e4..ebadeec0 100644
--- a/src/opt/res/resSim_old.c
+++ b/src/opt/res/resSim_old.c
@@ -21,6 +21,9 @@
 #include "abc.h"
 #include "resInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -327,14 +330,14 @@ void Res_SimPadSimInfo( Vec_Ptr_t * vPats, int nPats, int nWords )
     // pad the first word
     if ( nPats < 8 * sizeof(unsigned) )
     {
-        Vec_PtrForEachEntry( vPats, pInfo, i )
+        Vec_PtrForEachEntry( unsigned *, vPats, pInfo, i )
             if ( pInfo[0] & 1 )
                 pInfo[0] |= ((~0) << nPats);
         nPats = 8 * sizeof(unsigned);
     }
     // pad the empty words
     iWords = nPats / (8 * sizeof(unsigned));
-    Vec_PtrForEachEntry( vPats, pInfo, i )
+    Vec_PtrForEachEntry( unsigned *, vPats, pInfo, i )
     {
         for ( w = iWords; w < nWords; w++ )
             pInfo[w] = pInfo[0];
@@ -519,3 +522,5 @@ int Res_SimPrepare( Res_Sim_t * p, Abc_Ntk_t * pAig, int nTruePis, int fVerbose
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/res/resStrash.c b/src/opt/res/resStrash.c
index a75b84cc..9740af4c 100644
--- a/src/opt/res/resStrash.c
+++ b/src/opt/res/resStrash.c
@@ -21,6 +21,9 @@
 #include "abc.h"
 #include "resInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -55,12 +58,12 @@ Abc_Ntk_t * Res_WndStrash( Res_Win_t * p )
     pAig = Abc_NtkAlloc( ABC_NTK_STRASH, ABC_FUNC_AIG, 1 );
     pAig->pName = Extra_UtilStrsav( "window" );
     // create the inputs
-    Vec_PtrForEachEntry( p->vLeaves, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, p->vLeaves, pObj, i )
         pObj->pCopy = Abc_NtkCreatePi( pAig );
-    Vec_PtrForEachEntry( p->vBranches, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, p->vBranches, pObj, i )
         pObj->pCopy = Abc_NtkCreatePi( pAig );
     // go through the nodes in the topological order
-    Vec_PtrForEachEntry( p->vNodes, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, p->vNodes, pObj, i )
     {
         pObj->pCopy = Abc_ConvertAigToAig( pAig, pObj );
         if ( pObj == p->pNode )
@@ -68,7 +71,7 @@ Abc_Ntk_t * Res_WndStrash( Res_Win_t * p )
     }
     // collect the POs
     vPairs = Vec_PtrAlloc( 2 * Vec_PtrSize(p->vRoots) );
-    Vec_PtrForEachEntry( p->vRoots, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, p->vRoots, pObj, i )
     {
         Vec_PtrPush( vPairs, pObj->pCopy );
         Vec_PtrPush( vPairs, NULL );
@@ -80,16 +83,16 @@ Abc_Ntk_t * Res_WndStrash( Res_Win_t * p )
     p->pNode->pCopy = Abc_ObjNot( p->pNode->pCopy );
     Abc_NodeSetTravIdPrevious( p->pNode );
     // redo strashing in the TFO
-    Vec_PtrForEachEntry( p->vNodes, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, p->vNodes, pObj, i )
     {
         if ( Abc_NodeIsTravIdCurrent(pObj) )
             pObj->pCopy = Abc_ConvertAigToAig( pAig, pObj );
     }
     // collect the POs
-    Vec_PtrForEachEntry( p->vRoots, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, p->vRoots, pObj, i )
         Vec_PtrWriteEntry( vPairs, 2 * i + 1, pObj->pCopy );
     // add the miter
-    pMiter = Abc_AigMiter( pAig->pManFunc, vPairs, 0 );
+    pMiter = Abc_AigMiter( (Abc_Aig_t *)pAig->pManFunc, vPairs, 0 );
     Abc_ObjAddFanin( Abc_NtkCreatePo(pAig), pMiter );
     Vec_PtrFree( vPairs );
     // add the node
@@ -98,7 +101,7 @@ Abc_Ntk_t * Res_WndStrash( Res_Win_t * p )
     Abc_ObjForEachFanin( p->pNode, pObj, i )
         Abc_ObjAddFanin( Abc_NtkCreatePo(pAig), pObj->pCopy );
     // add the divisors
-    Vec_PtrForEachEntry( p->vDivs, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, p->vDivs, pObj, i )
         Abc_ObjAddFanin( Abc_NtkCreatePo(pAig), pObj->pCopy );
     // add the names
     Abc_NtkAddDummyPiNames( pAig );
@@ -115,3 +118,5 @@ Abc_Ntk_t * Res_WndStrash( Res_Win_t * p )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/res/resWin.c b/src/opt/res/resWin.c
index e46fdc70..a26e7831 100644
--- a/src/opt/res/resWin.c
+++ b/src/opt/res/resWin.c
@@ -21,6 +21,9 @@
 #include "abc.h"
 #include "resInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -113,7 +116,7 @@ int Res_WinCollectLeavesAndNodes( Res_Win_t * p )
     Vec_PtrClear( p->vLeaves );
     Vec_VecForEachLevelStartStop( p->vMatrix, vFront, i, 0, p->nWinTfiMax )
     {
-        Vec_PtrForEachEntry( vFront, pObj, k )
+        Vec_PtrForEachEntry( Abc_Obj_t *, vFront, pObj, k )
         {
             Abc_ObjForEachFanin( pObj, pTemp, m )
             {
@@ -134,14 +137,14 @@ int Res_WinCollectLeavesAndNodes( Res_Win_t * p )
     Vec_PtrClear( p->vNodes );
     Vec_VecForEachLevelReverseStartStop( p->vMatrix, vFront, i, p->nWinTfiMax, 0 )
     {
-        Vec_PtrForEachEntry( vFront, pObj, k )
+        Vec_PtrForEachEntry( Abc_Obj_t *, vFront, pObj, k )
             Vec_PtrPush( p->vNodes, pObj );
         Vec_PtrClear( vFront );
     }
 
     // get the lowest leaf level
     p->nLevLeafMin = ABC_INFINITY;
-    Vec_PtrForEachEntry( p->vLeaves, pObj, k )
+    Vec_PtrForEachEntry( Abc_Obj_t *, p->vLeaves, pObj, k )
         p->nLevLeafMin = ABC_MIN( p->nLevLeafMin, (int)pObj->Level );
 
     // set minimum traversal level
@@ -284,12 +287,12 @@ void Res_WinMarkPaths( Res_Win_t * p )
     // mark the leaves
     Abc_NtkIncrementTravId( p->pNode->pNtk );
     Abc_NtkIncrementTravId( p->pNode->pNtk );
-    Vec_PtrForEachEntry( p->vLeaves, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, p->vLeaves, pObj, i )
         Abc_NodeSetTravIdCurrent( pObj );
     // traverse from the roots and mark the nodes that can reach leaves
     // the nodes that do not reach leaves have previous trav ID
     // the nodes that reach leaves have current trav ID
-    Vec_PtrForEachEntry( p->vRoots, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, p->vRoots, pObj, i )
         Res_WinMarkPaths_rec( pObj, p->pNode, p->nLevTravMin );
 }
 
@@ -404,14 +407,14 @@ void Res_WinAddMissing( Res_Win_t * p )
     int i;
     // mark the leaves
     Abc_NtkIncrementTravId( p->pNode->pNtk );
-    Vec_PtrForEachEntry( p->vLeaves, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, p->vLeaves, pObj, i )
         Abc_NodeSetTravIdCurrent( pObj );        
     // mark the already collected nodes
-    Vec_PtrForEachEntry( p->vNodes, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, p->vNodes, pObj, i )
         Abc_NodeSetTravIdCurrent( pObj );        
     // explore from the roots
     Vec_PtrClear( p->vBranches );
-    Vec_PtrForEachEntry( p->vRoots, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, p->vRoots, pObj, i )
         Res_WinAddMissing_rec( p, pObj, p->nLevTravMin );
 }
 
@@ -483,3 +486,5 @@ int Res_WinCompute( Abc_Obj_t * pNode, int nWinTfiMax, int nWinTfoMax, Res_Win_t
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/res/res_.c b/src/opt/res/res_.c
index a50affd7..ffbc4946 100644
--- a/src/opt/res/res_.c
+++ b/src/opt/res/res_.c
@@ -21,6 +21,9 @@
 #include "abc.h"
 #include "res.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -48,3 +51,5 @@
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/ret/retArea.c b/src/opt/ret/retArea.c
index 63503916..38f95c22 100644
--- a/src/opt/ret/retArea.c
+++ b/src/opt/ret/retArea.c
@@ -20,6 +20,9 @@
 
 #include "retInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -227,7 +230,7 @@ void Abc_NtkRetimeMinAreaPrepare( Abc_Ntk_t * pNtk, int fForward )
                     if ( !pFanin->fMarkA )
                         Vec_PtrPush( vNodes, pFanin );
         // mark these nodes
-        Vec_PtrForEachEntry( vNodes, pObj, i )
+        Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
             pObj->fMarkA = 1;
         Vec_PtrFree( vNodes );
     }
@@ -270,7 +273,7 @@ int Abc_NtkRetimeMinAreaInitValues_rec( Abc_Obj_t * pObj )
     if ( Abc_ObjIsBo(pObj) )
     {
         assert( Abc_ObjIsLatch(Abc_ObjFanin0(pObj)) );
-        pObj->pCopy = (void *)(ABC_PTRUINT_T)Abc_NtkRetimeMinAreaInitValues_rec( Abc_ObjFanin0(pObj) );
+        pObj->pCopy = (Abc_Obj_t *)(ABC_PTRUINT_T)Abc_NtkRetimeMinAreaInitValues_rec( Abc_ObjFanin0(pObj) );
         return (int)(ABC_PTRUINT_T)pObj->pCopy;
     }
     assert( Abc_ObjIsNode(pObj) );
@@ -278,7 +281,7 @@ int Abc_NtkRetimeMinAreaInitValues_rec( Abc_Obj_t * pObj )
     Abc_ObjForEachFanin( pObj, pFanin, i )
         Abc_NtkRetimeMinAreaInitValues_rec( pFanin );
     // compute the value of the node
-    pObj->pCopy = (void *)(ABC_PTRUINT_T)Abc_ObjSopSimulate(pObj);
+    pObj->pCopy = (Abc_Obj_t *)(ABC_PTRUINT_T)Abc_ObjSopSimulate(pObj);
     return (int)(ABC_PTRUINT_T)pObj->pCopy;
 }
 
@@ -301,11 +304,11 @@ void Abc_NtkRetimeMinAreaInitValues( Abc_Ntk_t * pNtk, Vec_Ptr_t * vMinCut )
     Abc_NtkIncrementTravId(pNtk);
     Abc_NtkForEachLatch( pNtk, pObj, i )
     {
-        pObj->pCopy = (void *)(ABC_PTRUINT_T)Abc_LatchIsInit1(pObj);
+        pObj->pCopy = (Abc_Obj_t *)(ABC_PTRUINT_T)Abc_LatchIsInit1(pObj);
         Abc_NodeSetTravIdCurrent( pObj );
     }
     // propagate initial values
-    Vec_PtrForEachEntry( vMinCut, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vMinCut, pObj, i )
         Abc_NtkRetimeMinAreaInitValues_rec( pObj );
     // unmark the latches
     Abc_NtkForEachLatch( pNtk, pObj, i )
@@ -368,7 +371,7 @@ Abc_Ntk_t * Abc_NtkRetimeMinAreaConstructNtk( Abc_Ntk_t * pNtk, Vec_Ptr_t * vMin
     pNtkNew = Abc_NtkAlloc( ABC_NTK_LOGIC, ABC_FUNC_SOP, 1 );
     // map new latches into PIs of the new network
     Abc_NtkIncrementTravId(pNtk);
-    Vec_PtrForEachEntry( vMinCut, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vMinCut, pObj, i )
     {
         pObj->pCopy = Abc_NtkCreatePi(pNtkNew);
         Abc_NodeSetTravIdCurrent( pObj );
@@ -380,7 +383,7 @@ Abc_Ntk_t * Abc_NtkRetimeMinAreaConstructNtk( Abc_Ntk_t * pNtk, Vec_Ptr_t * vMin
         Abc_ObjAddFanin( Abc_NtkCreatePo(pNtkNew), pObjNew );
     }
     // unmark the nodes in the cut
-    Vec_PtrForEachEntry( vMinCut, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vMinCut, pObj, i )
         Abc_NodeSetTravIdPrevious( pObj );
     // unmark the latches
     Abc_NtkForEachLatch( pNtk, pObj, i )
@@ -418,13 +421,13 @@ void Abc_NtkRetimeMinAreaUpdateLatches( Abc_Ntk_t * pNtk, Vec_Ptr_t * vMinCut, i
     vBoxes = pNtk->vBoxes; pNtk->vBoxes = NULL; 
     // transfer boxes
     vBoxesNew = Vec_PtrAlloc(100);
-    Vec_PtrForEachEntry( vBoxes, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vBoxes, pObj, i )
         if ( !Abc_ObjIsLatch(pObj) )
             Vec_PtrPush( vBoxesNew, pObj );
     // create or reuse latches
     vNodes = Vec_PtrAlloc( 100 );
     vBuffers = Vec_PtrAlloc( 100 );
-    Vec_PtrForEachEntry( vMinCut, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vMinCut, pObj, i )
     {
         if ( Abc_ObjIsCi(pObj) && fForward )
         {
@@ -448,7 +451,7 @@ void Abc_NtkRetimeMinAreaUpdateLatches( Abc_Ntk_t * pNtk, Vec_Ptr_t * vMinCut, i
                 Vec_PtrPush( vBuffers, pBuffer );
                 // redirect edges to the unvisited fanouts of the node
                 Abc_NodeCollectFanouts( pObj, vNodes );
-                Vec_PtrForEachEntry( vNodes, pNext, k )
+                Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pNext, k )
                     if ( pNext->fMarkA )
                         Abc_ObjPatchFanin( pNext, pObj, pBuffer );
             }
@@ -481,7 +484,7 @@ void Abc_NtkRetimeMinAreaUpdateLatches( Abc_Ntk_t * pNtk, Vec_Ptr_t * vMinCut, i
                 pLatch->pData = (void *)(ABC_PTRUINT_T)(pObj->pCopy? ABC_INIT_ONE : ABC_INIT_ZERO);
                 // redirect edges to the unvisited fanouts of the node
                 Abc_NodeCollectFanouts( pObj, vNodes );
-                Vec_PtrForEachEntry( vNodes, pNext, k )
+                Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pNext, k )
                     if ( !pNext->fMarkA )
                         Abc_ObjPatchFanin( pNext, pObj, pLatchOut );
             }
@@ -489,7 +492,7 @@ void Abc_NtkRetimeMinAreaUpdateLatches( Abc_Ntk_t * pNtk, Vec_Ptr_t * vMinCut, i
             {
                 // redirect edges to the visited fanouts of the node
                 Abc_NodeCollectFanouts( pObj, vNodes );
-                Vec_PtrForEachEntry( vNodes, pNext, k )
+                Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pNext, k )
                     if ( pNext->fMarkA )
                         Abc_ObjPatchFanin( pNext, pObj, pLatchOut );
             }
@@ -502,14 +505,14 @@ void Abc_NtkRetimeMinAreaUpdateLatches( Abc_Ntk_t * pNtk, Vec_Ptr_t * vMinCut, i
     }
     Vec_PtrFree( vNodes );
     // remove buffers
-    Vec_PtrForEachEntry( vBuffers, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vBuffers, pObj, i )
     {
         Abc_ObjTransferFanout( pObj, Abc_ObjFanin0(pObj) );
         Abc_NtkDeleteObj( pObj );
     }
     Vec_PtrFree( vBuffers );
     // remove useless latches
-    Vec_PtrForEachEntry( vBoxes, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vBoxes, pObj, i )
     {
         if ( !Abc_ObjIsLatch(pObj) )
             continue;
@@ -537,3 +540,5 @@ void Abc_NtkRetimeMinAreaUpdateLatches( Abc_Ntk_t * pNtk, Vec_Ptr_t * vMinCut, i
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/ret/retCore.c b/src/opt/ret/retCore.c
index 9de1b723..1b574001 100644
--- a/src/opt/ret/retCore.c
+++ b/src/opt/ret/retCore.c
@@ -20,6 +20,9 @@
 
 #include "retInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -41,7 +44,7 @@ int timeRetime = 0;
   SeeAlso     []
 
 ***********************************************************************/
-int Abc_NtkRetime( Abc_Ntk_t * pNtk, int Mode, int fForwardOnly, int fBackwardOnly, int fOneStep, int fVerbose )
+int Abc_NtkRetime( Abc_Ntk_t * pNtk, int Mode, int nDelayLim, int fForwardOnly, int fBackwardOnly, int fOneStep, int fVerbose )
 {
     int nLatches = Abc_NtkLatchNum(pNtk);
     int nLevels  = Abc_NtkLevel(pNtk);
@@ -62,26 +65,26 @@ int Abc_NtkRetime( Abc_Ntk_t * pNtk, int Mode, int fForwardOnly, int fBackwardOn
     switch ( Mode )
     {
     case 1: // forward 
-        RetValue = Abc_NtkRetimeIncremental( pNtk, 1, 0, 0, fVerbose );
+        RetValue = Abc_NtkRetimeIncremental( pNtk, nDelayLim, 1, 0, 0, fVerbose );
         break;
     case 2: // backward 
-        RetValue = Abc_NtkRetimeIncremental( pNtk, 0, 0, 0, fVerbose );
+        RetValue = Abc_NtkRetimeIncremental( pNtk, nDelayLim, 0, 0, 0, fVerbose );
         break;
     case 3: // min-area 
         RetValue = Abc_NtkRetimeMinArea( pNtk, fForwardOnly, fBackwardOnly, fVerbose );
         break;
     case 4: // min-delay
         if ( !fBackwardOnly )
-            RetValue += Abc_NtkRetimeIncremental( pNtk, 1, 1, fOneStep, fVerbose );
+            RetValue += Abc_NtkRetimeIncremental( pNtk, nDelayLim, 1, 1, fOneStep, fVerbose );
         if ( !fForwardOnly )
-            RetValue += Abc_NtkRetimeIncremental( pNtk, 0, 1, fOneStep, fVerbose );
+            RetValue += Abc_NtkRetimeIncremental( pNtk, nDelayLim, 0, 1, fOneStep, fVerbose );
         break;
     case 5: // min-area + min-delay
         RetValue  = Abc_NtkRetimeMinArea( pNtk, fForwardOnly, fBackwardOnly, fVerbose );
         if ( !fBackwardOnly )
-            RetValue += Abc_NtkRetimeIncremental( pNtk, 1, 1, 0, fVerbose );
+            RetValue += Abc_NtkRetimeIncremental( pNtk, nDelayLim, 1, 1, 0, fVerbose );
         if ( !fForwardOnly )
-            RetValue += Abc_NtkRetimeIncremental( pNtk, 0, 1, 0, fVerbose );
+            RetValue += Abc_NtkRetimeIncremental( pNtk, nDelayLim, 0, 1, 0, fVerbose );
         break;
     case 6: // Pan's algorithm
         RetValue = Abc_NtkRetimeLValue( pNtk, 500, fVerbose );
@@ -121,7 +124,7 @@ int Abc_NtkRetimeDebug( Abc_Ntk_t * pNtk )
 //        fprintf( stdout, "Abc_NtkRetimeDebug(): Network check has failed.\n" );
 //    Io_WriteBlifLogic( pNtk, "debug_temp.blif", 1 );
     pNtkRet = Abc_NtkDup( pNtk );
-    Abc_NtkRetime( pNtkRet, 3, 0, 1, 0, 0 ); // debugging backward flow
+    Abc_NtkRetime( pNtkRet, 3, 0, 0, 1, 0, 0 ); // debugging backward flow
     return !Abc_NtkSecFraig( pNtk, pNtkRet, 10000, 3, 0 );
 }
 
@@ -130,3 +133,5 @@ int Abc_NtkRetimeDebug( Abc_Ntk_t * pNtk )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/ret/retDelay.c b/src/opt/ret/retDelay.c
index 0f3c3daa..0263c92f 100644
--- a/src/opt/ret/retDelay.c
+++ b/src/opt/ret/retDelay.c
@@ -20,11 +20,14 @@
 
 #include "retInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
 
-static int Abc_NtkRetimeMinDelayTry( Abc_Ntk_t * pNtk, int fForward, int fInitial, int nIterLimit, int * pIterBest, int fVerbose );
+static int Abc_NtkRetimeMinDelayTry( Abc_Ntk_t * pNtk, int nDelayLim, int fForward, int fInitial, int nIterLimit, int * pIterBest, int fVerbose );
 static int Abc_NtkRetimeTiming( Abc_Ntk_t * pNtk, int fForward, Vec_Ptr_t * vCritical );
 static int Abc_NtkRetimeTiming_rec( Abc_Obj_t * pObj, int fForward );
 
@@ -44,16 +47,16 @@ static int Abc_NtkRetimeTiming_rec( Abc_Obj_t * pObj, int fForward );
   SeeAlso     []
 
 ***********************************************************************/
-int Abc_NtkRetimeMinDelay( Abc_Ntk_t * pNtk, Abc_Ntk_t * pNtkCopy, int nIterLimit, int fForward, int fVerbose )
+int Abc_NtkRetimeMinDelay( Abc_Ntk_t * pNtk, Abc_Ntk_t * pNtkCopy, int nDelayLim, int nIterLimit, int fForward, int fVerbose )
 {
     int IterBest, DelayBest;
     int IterBest2, DelayBest2;
     // try to find the best delay iteration on a copy
-    DelayBest = Abc_NtkRetimeMinDelayTry( pNtkCopy, fForward, 0, nIterLimit, &IterBest, fVerbose );
+    DelayBest = Abc_NtkRetimeMinDelayTry( pNtkCopy, nDelayLim, fForward, 0, nIterLimit, &IterBest, fVerbose );
     if ( IterBest == 0 )
         return 1;
     // perform the given number of iterations on the original network
-    DelayBest2 = Abc_NtkRetimeMinDelayTry( pNtk, fForward, 1, IterBest, &IterBest2, fVerbose );
+    DelayBest2 = Abc_NtkRetimeMinDelayTry( pNtk, nDelayLim, fForward, 1, IterBest, &IterBest2, fVerbose );
     assert( DelayBest == DelayBest2 );
     assert( IterBest == IterBest2 );
     return 1;
@@ -70,7 +73,7 @@ int Abc_NtkRetimeMinDelay( Abc_Ntk_t * pNtk, Abc_Ntk_t * pNtkCopy, int nIterLimi
   SeeAlso     []
 
 ***********************************************************************/
-int Abc_NtkRetimeMinDelayTry( Abc_Ntk_t * pNtk, int fForward, int fInitial, int nIterLimit, int * pIterBest, int fVerbose )
+int Abc_NtkRetimeMinDelayTry( Abc_Ntk_t * pNtk, int nDelayLim, int fForward, int fInitial, int nIterLimit, int * pIterBest, int fVerbose )
 {
     Abc_Ntk_t * pNtkNew = NULL;
     Vec_Ptr_t * vCritical;
@@ -123,8 +126,11 @@ if ( fVerbose && !fInitial )
         // skip if 10 interations did not give improvement
         if ( i - IterBest > 20 )
             break;
+        // skip if delay limit is reached
+        if ( nDelayLim > 0 && DelayCur <= nDelayLim )
+            break;
         // try retiming to improve the delay
-        Vec_PtrForEachEntry( vCritical, pObj, k )
+        Vec_PtrForEachEntry( Abc_Obj_t *, vCritical, pObj, k )
             if ( Abc_NtkRetimeNodeIsEnabled(pObj, fForward) )
                 Abc_NtkRetimeNode( pObj, fForward, fInitial );
         // share latches
@@ -183,7 +189,7 @@ int Abc_NtkRetimeTiming( Abc_Ntk_t * pNtk, int fForward, Vec_Ptr_t * vCritical )
     // perform analysis from CIs/COs
     if ( fForward )
     {
-        Vec_PtrForEachEntry( vLatches, pObj, i )
+        Vec_PtrForEachEntry( Abc_Obj_t *, vLatches, pObj, i )
         {
             Abc_ObjForEachFanout( pObj, pNext, k )
             {
@@ -204,7 +210,7 @@ int Abc_NtkRetimeTiming( Abc_Ntk_t * pNtk, int fForward, Vec_Ptr_t * vCritical )
     }
     else
     {
-        Vec_PtrForEachEntry( vLatches, pObj, i )
+        Vec_PtrForEachEntry( Abc_Obj_t *, vLatches, pObj, i )
         {
             LevelCur = Abc_NtkRetimeTiming_rec( Abc_ObjFanin0(pObj), fForward );
             if ( LevelMax < LevelCur )
@@ -222,7 +228,7 @@ int Abc_NtkRetimeTiming( Abc_Ntk_t * pNtk, int fForward, Vec_Ptr_t * vCritical )
     Abc_NtkIncrementTravId(pNtk);
     if ( fForward )
     {
-        Vec_PtrForEachEntry( vLatches, pObj, i )
+        Vec_PtrForEachEntry( Abc_Obj_t *, vLatches, pObj, i )
         {
             Abc_ObjForEachFanout( pObj, pNext, k )
             {
@@ -238,7 +244,7 @@ int Abc_NtkRetimeTiming( Abc_Ntk_t * pNtk, int fForward, Vec_Ptr_t * vCritical )
     }
     else
     {
-        Vec_PtrForEachEntry( vLatches, pObj, i )
+        Vec_PtrForEachEntry( Abc_Obj_t *, vLatches, pObj, i )
         {
             Abc_ObjForEachFanin( pObj, pNext, k )
             {
@@ -305,3 +311,5 @@ int Abc_NtkRetimeTiming_rec( Abc_Obj_t * pObj, int fForward )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/ret/retFlow.c b/src/opt/ret/retFlow.c
index 7c17c1f6..f684939c 100644
--- a/src/opt/ret/retFlow.c
+++ b/src/opt/ret/retFlow.c
@@ -20,6 +20,9 @@
 
 #include "retInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -261,7 +264,7 @@ int Abc_NtkMaxFlowBwdPath_rec( Abc_Obj_t * pObj )
     {
         // start the path if we reached a terminal node
         if ( pObj->fMarkA )
-            return Abc_ObjSetPath( pObj, (void *)1 );
+            return Abc_ObjSetPath( pObj, (Abc_Obj_t *)1 );
         // explore the fanins
         Abc_ObjForEachFanin( pObj, pNext, i )
             if ( pNext != pPred && !Abc_ObjIsLatch(pNext) && Abc_NtkMaxFlowBwdPath_rec(pNext) )
@@ -313,7 +316,7 @@ int Abc_NtkMaxFlowFwdPath_rec( Abc_Obj_t * pObj )
     {
         // start the path if we reached a terminal node
         if ( pObj->fMarkA )
-            return Abc_ObjSetPath( pObj, (void *)1 );
+            return Abc_ObjSetPath( pObj, (Abc_Obj_t *)1 );
         // explore the fanins
         Abc_ObjForEachFanout( pObj, pNext, i )
             if ( pNext != pPred && !Abc_ObjIsLatch(pNext) && Abc_NtkMaxFlowFwdPath_rec(pNext) )
@@ -367,7 +370,7 @@ int Abc_NtkMaxFlowFwdPath3_rec( Abc_Obj_t * pObj, Abc_Obj_t * pPrev, int fFanin
     {
         // start the path if we reached a terminal node
         if ( pObj->fMarkA )
-            return Abc_ObjSetPath( pObj, (void *)1 );
+            return Abc_ObjSetPath( pObj, (Abc_Obj_t *)1 );
         // try to push flow through the fanouts
         Abc_ObjForEachFanout( pObj, pFanout, i )
             if ( Abc_NtkMaxFlowFwdPath3_rec(pFanout, pObj, 1) )
@@ -404,7 +407,7 @@ int Abc_NtkMaxFlowBwdPath2_rec( Abc_Obj_t * pObj )
     {
         // start the path if we reached a terminal node
         if ( pObj->fMarkA )
-            return Abc_ObjSetPath( pObj, (void *)1 );
+            return Abc_ObjSetPath( pObj, (Abc_Obj_t *)1 );
         // explore the fanins
         Abc_ObjForEachFanin( pObj, pFanin, i )
             if ( Abc_NtkMaxFlowBwdPath2_rec(pFanin) )
@@ -449,7 +452,7 @@ int Abc_NtkMaxFlowFwdPath2_rec( Abc_Obj_t * pObj )
     { 
         // start the path if we reached a terminal node
         if ( pObj->fMarkA )
-            return Abc_ObjSetPath( pObj, (void *)1 );
+            return Abc_ObjSetPath( pObj, (Abc_Obj_t *)1 );
         // explore the fanins
         Abc_ObjForEachFanout( pObj, pFanout, i )
             if ( Abc_NtkMaxFlowFwdPath2_rec(pFanout) )
@@ -575,7 +578,7 @@ void Abc_NtkMaxFlowMinCutUpdate( Abc_Ntk_t * pNtk, Vec_Ptr_t * vMinCut, int fFor
     Abc_NtkForEachLatch( pNtk, pObj, i )
         Abc_ObjFanout0(pObj)->fMarkA = 1;
     // traverse from cut nodes
-    Vec_PtrForEachEntry( vMinCut, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vMinCut, pObj, i )
         Abc_NtkMaxFlowMarkCut_rec( pObj );
     if ( fForward )
     {
@@ -605,7 +608,7 @@ void Abc_NtkMaxFlowMinCutUpdate( Abc_Ntk_t * pNtk, Vec_Ptr_t * vMinCut, int fFor
         Abc_NtkForEachObj( pNtk, pObj, i )
             pObj->fMarkA = Abc_NodeIsTravIdCurrent(pObj);
         // unmark the cut nodes
-        Vec_PtrForEachEntry( vMinCut, pObj, i )
+        Vec_PtrForEachEntry( Abc_Obj_t *, vMinCut, pObj, i )
             pObj->fMarkA = 0;
     }
 }
@@ -668,7 +671,7 @@ int Abc_NtkMaxFlowVerifyCut( Abc_Ntk_t * pNtk, Vec_Ptr_t * vMinCut, int fForward
     int i;
     // mark the cut with the current traversal ID
     Abc_NtkIncrementTravId(pNtk);
-    Vec_PtrForEachEntry( vMinCut, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vMinCut, pObj, i )
         Abc_NodeSetTravIdCurrent( pObj );
     // search from the latches for a path to the COs/CIs
     Abc_NtkForEachLatch( pNtk, pObj, i )
@@ -714,7 +717,7 @@ void Abc_NtkMaxFlowPrintFlow( Abc_Ntk_t * pNtk, int fForward )
     int i;
     if ( fForward )
     {
-        Vec_PtrForEachEntry( pNtk->vBoxes, pLatch, i )
+        Vec_PtrForEachEntry( Abc_Obj_t *, pNtk->vBoxes, pLatch, i )
         {
             assert( !Abc_ObjFanout0(pLatch)->fMarkA );
             if ( Abc_ObjGetPath(Abc_ObjFanout0(pLatch)) == NULL ) // no flow through this latch
@@ -732,7 +735,7 @@ void Abc_NtkMaxFlowPrintFlow( Abc_Ntk_t * pNtk, int fForward )
     }
     else
     {
-        Vec_PtrForEachEntry( pNtk->vBoxes, pLatch, i )
+        Vec_PtrForEachEntry( Abc_Obj_t *, pNtk->vBoxes, pLatch, i )
         {
             assert( !Abc_ObjFanin0(pLatch)->fMarkA );
             if ( Abc_ObjGetPath(Abc_ObjFanin0(pLatch)) == NULL ) // no flow through this latch
@@ -766,7 +769,7 @@ void Abc_NtkMaxFlowPrintCut( Abc_Ntk_t * pNtk, Vec_Ptr_t * vMinCut )
     Abc_Obj_t * pObj;
     int i;
     printf( "Min-cut: " );
-    Vec_PtrForEachEntry( vMinCut, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vMinCut, pObj, i )
         printf( "%s(%d) ", Abc_ObjName(pObj), pObj->Id );
     printf( "\n" );
     printf( "Marked nodes: " );
@@ -782,3 +785,5 @@ void Abc_NtkMaxFlowPrintCut( Abc_Ntk_t * pNtk, Vec_Ptr_t * vMinCut )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/ret/retIncrem.c b/src/opt/ret/retIncrem.c
index 1866e4c9..80b26914 100644
--- a/src/opt/ret/retIncrem.c
+++ b/src/opt/ret/retIncrem.c
@@ -20,6 +20,9 @@
 
 #include "retInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -41,7 +44,7 @@ static int Abc_NtkRetimeOneWay( Abc_Ntk_t * pNtk, int fForward, int fVerbose );
   SeeAlso     []
 
 ***********************************************************************/
-int Abc_NtkRetimeIncremental( Abc_Ntk_t * pNtk, int fForward, int fMinDelay, int fOneStep, int fVerbose )
+int Abc_NtkRetimeIncremental( Abc_Ntk_t * pNtk, int nDelayLim, int fForward, int fMinDelay, int fOneStep, int fVerbose )
 {
     Abc_Ntk_t * pNtkCopy = NULL;
     Vec_Ptr_t * vBoxes;
@@ -69,7 +72,7 @@ int Abc_NtkRetimeIncremental( Abc_Ntk_t * pNtk, int fForward, int fMinDelay, int
     vBoxes = pNtk->vBoxes;  pNtk->vBoxes = NULL;
     // perform the retiming
     if ( fMinDelay )
-        Abc_NtkRetimeMinDelay( pNtk, pNtkCopy, nIterLimit, fForward, fVerbose );
+        Abc_NtkRetimeMinDelay( pNtk, pNtkCopy, nDelayLim, nIterLimit, fForward, fVerbose );
     else
         Abc_NtkRetimeOneWay( pNtk, fForward, fVerbose );
     if ( fMinDelay ) 
@@ -113,7 +116,7 @@ st_table * Abc_NtkRetimePrepareLatches( Abc_Ntk_t * pNtk )
     Abc_NtkForEachLatch( pNtk, pLatch, i )
     {
         // map latch into its true number
-        st_insert( tLatches, (void *)(ABC_PTRUINT_T)pLatch, (void *)(ABC_PTRUINT_T)(i-nOffSet) );
+        st_insert( tLatches, (char *)(ABC_PTRUINT_T)pLatch, (char *)(ABC_PTRUINT_T)(i-nOffSet) );
         // disconnect LI     
         pLatchIn = Abc_ObjFanin0(pLatch);
         pFanin = Abc_ObjFanin0(pLatchIn);
@@ -150,11 +153,11 @@ int Abc_NtkRetimeFinalizeLatches( Abc_Ntk_t * pNtk, st_table * tLatches, int nId
     vCosOld   = pNtk->vCos;    pNtk->vCos   = NULL;  vCosNew   = Vec_PtrAlloc( 100 );  
     vBoxesOld = pNtk->vBoxes;  pNtk->vBoxes = NULL;  vBoxesNew = Vec_PtrAlloc( 100 );
     // copy boxes and their CIs/COs
-    Vec_PtrForEachEntryStop( vCisOld, pObj, i, Vec_PtrSize(vCisOld) - st_count(tLatches) )
+    Vec_PtrForEachEntryStop( Abc_Obj_t *, vCisOld, pObj, i, Vec_PtrSize(vCisOld) - st_count(tLatches) )
         Vec_PtrPush( vCisNew, pObj );
-    Vec_PtrForEachEntryStop( vCosOld, pObj, i, Vec_PtrSize(vCosOld) - st_count(tLatches) )
+    Vec_PtrForEachEntryStop( Abc_Obj_t *, vCosOld, pObj, i, Vec_PtrSize(vCosOld) - st_count(tLatches) )
         Vec_PtrPush( vCosNew, pObj );
-    Vec_PtrForEachEntryStop( vBoxesOld, pObj, i, Vec_PtrSize(vBoxesOld) - st_count(tLatches) )
+    Vec_PtrForEachEntryStop( Abc_Obj_t *, vBoxesOld, pObj, i, Vec_PtrSize(vBoxesOld) - st_count(tLatches) )
         Vec_PtrPush( vBoxesNew, pObj );
     // go through the latches
     Abc_NtkForEachObj( pNtk, pLatch, i )
@@ -180,8 +183,8 @@ int Abc_NtkRetimeFinalizeLatches( Abc_Ntk_t * pNtk, st_table * tLatches, int nId
             }
             assert( pLatch == Vec_PtrEntry(vBoxesOld, Vec_PtrSize(vBoxesOld) - st_count(tLatches) + Index) );
             // reconnect with the old LIs/LOs
-            pLatchIn  = Vec_PtrEntry( vCosOld, Vec_PtrSize(vCosOld) - st_count(tLatches) + Index );
-            pLatchOut = Vec_PtrEntry( vCisOld, Vec_PtrSize(vCisOld) - st_count(tLatches) + Index );
+            pLatchIn  = (Abc_Obj_t *)Vec_PtrEntry( vCosOld, Vec_PtrSize(vCosOld) - st_count(tLatches) + Index );
+            pLatchOut = (Abc_Obj_t *)Vec_PtrEntry( vCisOld, Vec_PtrSize(vCisOld) - st_count(tLatches) + Index );
         }
         // connect
         Abc_ObjAddFanin( pLatchIn, Abc_ObjFanin0(pLatch) );
@@ -195,10 +198,10 @@ int Abc_NtkRetimeFinalizeLatches( Abc_Ntk_t * pNtk, st_table * tLatches, int nId
         Vec_PtrPush( vBoxesNew, pLatch );
     }
     // free useless Cis/Cos
-    Vec_PtrForEachEntry( vCisOld, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vCisOld, pObj, i )
         if ( !Abc_ObjIsPi(pObj) && Abc_ObjFaninNum(pObj) == 0 && Abc_ObjFanoutNum(pObj) == 0 )
             Abc_NtkDeleteObj(pObj);
-    Vec_PtrForEachEntry( vCosOld, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vCosOld, pObj, i )
         if ( !Abc_ObjIsPo(pObj) && Abc_ObjFaninNum(pObj) == 0 && Abc_ObjFanoutNum(pObj) == 0 )
             Abc_NtkDeleteObj(pObj);
     // set the new arrays
@@ -316,15 +319,15 @@ void Abc_NtkRetimeNode( Abc_Obj_t * pObj, int fForward, int fInitial )
     Abc_Obj_t * pNext, * pLatch;
     int i;
     vNodes = Vec_PtrAlloc( 10 );
-    if ( fForward )
+    if ( fForward ) 
     {
         // compute the initial value
         if ( fInitial )
-            pObj->pCopy = (void *)(ABC_PTRUINT_T)Abc_ObjSopSimulate( pObj );
+            pObj->pCopy = (Abc_Obj_t *)(ABC_PTRUINT_T)Abc_ObjSopSimulate( pObj );
         // collect fanins
         Abc_NodeCollectFanins( pObj, vNodes );
         // make the node point to the fanins fanins
-        Vec_PtrForEachEntry( vNodes, pNext, i )
+        Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pNext, i )
         {
             assert( Abc_ObjIsLatch(pNext) );
             Abc_ObjPatchFanin( pObj, pNext, Abc_ObjFanin0(pNext) );
@@ -356,7 +359,7 @@ void Abc_NtkRetimeNode( Abc_Obj_t * pObj, int fForward, int fInitial )
         // collect fanouts
         Abc_NodeCollectFanouts( pObj, vNodes );
         // make the fanouts fanouts point to the node
-        Vec_PtrForEachEntry( vNodes, pNext, i )
+        Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pNext, i )
         {
             assert( Abc_ObjIsLatch(pNext) );
             Abc_ObjTransferFanout( pNext, pObj );
@@ -439,7 +442,7 @@ void Abc_NtkRetimeShareLatches( Abc_Ntk_t * pNtk, int fInitial )
         assert( pLatchTop && Abc_ObjIsLatch(pLatchTop) );
         // redirect compatible fanout latches to the first latch
         Abc_NodeCollectFanouts( pFanin, vNodes );
-        Vec_PtrForEachEntry( vNodes, pLatchCur, k )
+        Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pLatchCur, k )
         {
             if ( !Abc_ObjIsLatch(pLatchCur) )
                 continue;
@@ -463,3 +466,5 @@ void Abc_NtkRetimeShareLatches( Abc_Ntk_t * pNtk, int fInitial )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/ret/retInit.c b/src/opt/ret/retInit.c
index 72b384d9..44331e72 100644
--- a/src/opt/ret/retInit.c
+++ b/src/opt/ret/retInit.c
@@ -20,6 +20,9 @@
 
 #include "retInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -88,7 +91,7 @@ Vec_Int_t * Abc_NtkRetimeInitialValues( Abc_Ntk_t * pNtkCone, Vec_Int_t * vValue
 ***********************************************************************/
 int Abc_ObjSopSimulate( Abc_Obj_t * pObj )
 {
-    char * pCube, * pSop = pObj->pData;
+    char * pCube, * pSop = (char *)pObj->pData;
     int nVars, Value, v, ResOr, ResAnd, ResVar;
     assert( pSop && !Abc_SopIsExorType(pSop) );
     // simulate the SOP of the node
@@ -134,11 +137,11 @@ int Abc_NtkRetimeVerifyModel( Abc_Ntk_t * pNtkCone, Vec_Int_t * vValues, int * p
     assert( Abc_NtkIsSopLogic(pNtkCone) );
     // set the PIs
     Abc_NtkForEachPi( pNtkCone, pObj, i )
-        pObj->pCopy = (void *)(ABC_PTRUINT_T)pModel[i];
+        pObj->pCopy = (Abc_Obj_t *)(ABC_PTRUINT_T)pModel[i];
     // simulate the internal nodes
     vNodes = Abc_NtkDfs( pNtkCone, 0 );
-    Vec_PtrForEachEntry( vNodes, pObj, i )
-        pObj->pCopy = (void *)(ABC_PTRUINT_T)Abc_ObjSopSimulate( pObj );
+    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
+        pObj->pCopy = (Abc_Obj_t *)(ABC_PTRUINT_T)Abc_ObjSopSimulate( pObj );
     Vec_PtrFree( vNodes );
     // compare the outputs
     Abc_NtkForEachPo( pNtkCone, pObj, i )
@@ -167,7 +170,7 @@ void Abc_NtkRetimeTranferToCopy( Abc_Ntk_t * pNtk )
     int i;
     Abc_NtkForEachObj( pNtk, pObj, i )
         if ( Abc_ObjIsLatch(pObj) )
-            pObj->pCopy = (void *)(ABC_PTRUINT_T)Abc_LatchIsInit1(pObj);
+            pObj->pCopy = (Abc_Obj_t *)(ABC_PTRUINT_T)Abc_LatchIsInit1(pObj);
 }
 
 /**Function*************************************************************
@@ -230,10 +233,10 @@ void Abc_NtkRetimeInsertLatchValues( Abc_Ntk_t * pNtk, Vec_Int_t * vValues )
     int i, Counter = 0;
     Abc_NtkForEachObj( pNtk, pObj, i )
         if ( Abc_ObjIsLatch(pObj) )
-            pObj->pCopy = (void *)(ABC_PTRUINT_T)Counter++;
+            pObj->pCopy = (Abc_Obj_t *)(ABC_PTRUINT_T)Counter++;
     Abc_NtkForEachObj( pNtk, pObj, i )
         if ( Abc_ObjIsLatch(pObj) )
-            pObj->pData = (void *)(ABC_PTRUINT_T)(vValues? (Vec_IntEntry(vValues,(int)(ABC_PTRUINT_T)pObj->pCopy)? ABC_INIT_ONE : ABC_INIT_ZERO) : ABC_INIT_DC);
+            pObj->pData = (Abc_Obj_t *)(ABC_PTRUINT_T)(vValues? (Vec_IntEntry(vValues,(int)(ABC_PTRUINT_T)pObj->pCopy)? ABC_INIT_ONE : ABC_INIT_ZERO) : ABC_INIT_DC);
 }
 
 /**Function*************************************************************
@@ -316,22 +319,22 @@ void Abc_NtkCycleInitStateSop( Abc_Ntk_t * pNtk, int nFrames, int fVerbose )
     srand( 0x12341234 );
     // initialize the values
     Abc_NtkForEachPi( pNtk, pObj, i )
-        pObj->pCopy = (void *)(ABC_PTRUINT_T)(rand() & 1);
+        pObj->pCopy = (Abc_Obj_t *)(ABC_PTRUINT_T)(rand() & 1);
     Abc_NtkForEachLatch( pNtk, pObj, i )
-        pObj->pCopy = (void *)(ABC_PTRUINT_T)Abc_LatchIsInit1(pObj);
+        pObj->pCopy = (Abc_Obj_t *)(ABC_PTRUINT_T)Abc_LatchIsInit1(pObj);
     // simulate for the given number of timeframes
     vNodes = Abc_NtkDfs( pNtk, 0 );
     for ( f = 0; f < nFrames; f++ )
     {
         // simulate internal nodes
-        Vec_PtrForEachEntry( vNodes, pObj, i )
-            pObj->pCopy = (void *)(ABC_PTRUINT_T)Abc_ObjSopSimulate( pObj );
+        Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
+            pObj->pCopy = (Abc_Obj_t *)(ABC_PTRUINT_T)Abc_ObjSopSimulate( pObj );
         // bring the results to the COs
         Abc_NtkForEachCo( pNtk, pObj, i )
             pObj->pCopy = Abc_ObjFanin0(pObj)->pCopy;
         // assign PI values
         Abc_NtkForEachPi( pNtk, pObj, i )
-            pObj->pCopy = (void *)(ABC_PTRUINT_T)(rand() & 1);
+            pObj->pCopy = (Abc_Obj_t *)(ABC_PTRUINT_T)(rand() & 1);
         // transfer the latch values
         Abc_NtkForEachLatch( pNtk, pObj, i )
             Abc_ObjFanout0(pObj)->pCopy = Abc_ObjFanin0(pObj)->pCopy;
@@ -347,3 +350,5 @@ void Abc_NtkCycleInitStateSop( Abc_Ntk_t * pNtk, int nFrames, int fVerbose )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/ret/retInt.h b/src/opt/ret/retInt.h
index 51428bce..39a6296e 100644
--- a/src/opt/ret/retInt.h
+++ b/src/opt/ret/retInt.h
@@ -21,12 +21,16 @@
 #ifndef __RET_INT_H__
 #define __RET_INT_H__
 
+
 ////////////////////////////////////////////////////////////////////////
 ///                          INCLUDES                                ///
 ////////////////////////////////////////////////////////////////////////
 
 #include "abc.h"
 
+ABC_NAMESPACE_HEADER_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                         PARAMETERS                               ///
 ////////////////////////////////////////////////////////////////////////
@@ -46,11 +50,11 @@
 /*=== retArea.c ========================================================*/
 extern int         Abc_NtkRetimeMinArea( Abc_Ntk_t * pNtk, int fForwardOnly, int fBackwardOnly, int fVerbose );
 /*=== retCore.c ========================================================*/
-extern int         Abc_NtkRetime( Abc_Ntk_t * pNtk, int Mode, int fForwardOnly, int fBackwardOnly, int fOneStep, int fVerbose );
+extern int         Abc_NtkRetime( Abc_Ntk_t * pNtk, int Mode, int nDelayLim, int fForwardOnly, int fBackwardOnly, int fOneStep, int fVerbose );
 /*=== retDelay.c ========================================================*/
-extern int         Abc_NtkRetimeMinDelay( Abc_Ntk_t * pNtk, Abc_Ntk_t * pNtkCopy, int nIterLimit, int fForward, int fVerbose );
+extern int         Abc_NtkRetimeMinDelay( Abc_Ntk_t * pNtk, Abc_Ntk_t * pNtkCopy, int nDelayLim, int nIterLimit, int fForward, int fVerbose );
 /*=== retDirect.c ========================================================*/
-extern int         Abc_NtkRetimeIncremental( Abc_Ntk_t * pNtk, int fForward, int fMinDelay, int fOneStep, int fVerbose );
+extern int         Abc_NtkRetimeIncremental( Abc_Ntk_t * pNtk, int nDelayLim, int fForward, int fMinDelay, int fOneStep, int fVerbose );
 extern void        Abc_NtkRetimeShareLatches( Abc_Ntk_t * pNtk, int fInitial );
 extern int         Abc_NtkRetimeNodeIsEnabled( Abc_Obj_t * pObj, int fForward );
 extern void        Abc_NtkRetimeNode( Abc_Obj_t * pObj, int fForward, int fInitial );
@@ -71,6 +75,10 @@ extern void        Abc_NtkRetimeBackwardInitialFinish( Abc_Ntk_t * pNtk, Abc_Ntk
 /*=== retLvalue.c ========================================================*/
 extern int         Abc_NtkRetimeLValue( Abc_Ntk_t * pNtk, int nIterLimit, int fVerbose );
 
+
+
+ABC_NAMESPACE_HEADER_END
+
 #endif
 
 ////////////////////////////////////////////////////////////////////////
diff --git a/src/opt/ret/retLvalue.c b/src/opt/ret/retLvalue.c
index 02d9cac2..7d32dd7d 100644
--- a/src/opt/ret/retLvalue.c
+++ b/src/opt/ret/retLvalue.c
@@ -20,6 +20,9 @@
 
 #include "retInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -38,7 +41,7 @@ static int         Abc_NtkRetimeUsingLags( Abc_Ntk_t * pNtk, Vec_Int_t * vLags,
 
 static inline int  Abc_NodeComputeLag( int LValue, int Fi )          { return (LValue + (1<<16)*Fi)/Fi - (1<<16) - (int)(LValue % Fi == 0);     }
 static inline int  Abc_NodeGetLValue( Abc_Obj_t * pNode )            { return (int)(ABC_PTRUINT_T)pNode->pCopy;        }
-static inline void Abc_NodeSetLValue( Abc_Obj_t * pNode, int Value ) { pNode->pCopy = (void *)(ABC_PTRUINT_T)Value;    }
+static inline void Abc_NodeSetLValue( Abc_Obj_t * pNode, int Value ) { pNode->pCopy = (Abc_Obj_t *)(ABC_PTRUINT_T)Value;    }
 
 ////////////////////////////////////////////////////////////////////////
 ///                     FUNCTION DEFINITIONS                         ///
@@ -247,7 +250,7 @@ int Abc_NtkRetimeUpdateLValue( Abc_Ntk_t * pNtk, Vec_Ptr_t * vNodes, Vec_Ptr_t *
     int i, k, lValueNew, fChange;
     // go through the nodes and detect change
     fChange = 0;
-    Vec_PtrForEachEntry( vNodes, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
     {
         assert( Abc_ObjIsNode(pObj) );
         lValueNew = -ABC_INFINITY;
@@ -264,7 +267,7 @@ int Abc_NtkRetimeUpdateLValue( Abc_Ntk_t * pNtk, Vec_Ptr_t * vNodes, Vec_Ptr_t *
         }
     }
     // propagate values through the latches
-    Vec_PtrForEachEntry( vLatches, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vLatches, pObj, i )
         Abc_NodeSetLValue( Abc_ObjFanout0(pObj), Abc_NodeGetLValue(Abc_ObjFanin0(Abc_ObjFanin0(pObj))) - Fi );
     return fChange;
 }
@@ -393,3 +396,5 @@ int Abc_NtkRetimeUsingLags( Abc_Ntk_t * pNtk, Vec_Int_t * vLags, int fVerbose )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/ret/ret_.c b/src/opt/ret/ret_.c
index 89625e17..1ee46e4a 100644
--- a/src/opt/ret/ret_.c
+++ b/src/opt/ret/ret_.c
@@ -20,6 +20,9 @@
 
 #include "retInt.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -46,3 +49,5 @@
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/rwr/rwr.h b/src/opt/rwr/rwr.h
index 5adc3b4b..ed05d4a3 100644
--- a/src/opt/rwr/rwr.h
+++ b/src/opt/rwr/rwr.h
@@ -21,6 +21,7 @@
 #ifndef __RWR_H__
 #define __RWR_H__
 
+
 ////////////////////////////////////////////////////////////////////////
 ///                          INCLUDES                                ///
 ////////////////////////////////////////////////////////////////////////
@@ -32,9 +33,10 @@
 ///                         PARAMETERS                               ///
 ////////////////////////////////////////////////////////////////////////
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+
+
+ABC_NAMESPACE_HEADER_START
+
 
 ////////////////////////////////////////////////////////////////////////
 ///                         BASIC TYPES                              ///
@@ -111,7 +113,7 @@ struct Rwr_Node_t_ // 24 bytes
 };
 
 // manipulation of complemented attributes
-static inline bool         Rwr_IsComplement( Rwr_Node_t * p )    { return (bool)(((ABC_PTRUINT_T)p) & 01);           }
+static inline int          Rwr_IsComplement( Rwr_Node_t * p )    { return (int )(((ABC_PTRUINT_T)p) & 01);           }
 static inline Rwr_Node_t * Rwr_Regular( Rwr_Node_t * p )         { return (Rwr_Node_t *)((ABC_PTRUINT_T)(p) & ~01);  }
 static inline Rwr_Node_t * Rwr_Not( Rwr_Node_t * p )             { return (Rwr_Node_t *)((ABC_PTRUINT_T)(p) ^  01);  }
 static inline Rwr_Node_t * Rwr_NotCond( Rwr_Node_t * p, int c )  { return (Rwr_Node_t *)((ABC_PTRUINT_T)(p) ^ (c));  }
@@ -137,7 +139,7 @@ extern Rwr_Node_t *      Rwr_ManAddNode( Rwr_Man_t * p, Rwr_Node_t * p0, Rwr_Nod
 extern int               Rwr_ManNodeVolume( Rwr_Man_t * p, Rwr_Node_t * p0, Rwr_Node_t * p1 );
 extern void              Rwr_ManIncTravId( Rwr_Man_t * p );
 /*=== rwrMan.c ========================================================*/
-extern Rwr_Man_t *       Rwr_ManStart( bool fPrecompute );
+extern Rwr_Man_t *       Rwr_ManStart( int  fPrecompute );
 extern void              Rwr_ManStop( Rwr_Man_t * p );
 extern void              Rwr_ManPrintStats( Rwr_Man_t * p );
 extern void              Rwr_ManPrintStatsFile( Rwr_Man_t * p );
@@ -157,9 +159,11 @@ extern void              Rwr_ManLoadFromFile( Rwr_Man_t * p, char * pFileName );
 extern void              Rwr_ListAddToTail( Rwr_Node_t ** ppList, Rwr_Node_t * pNode );
 extern char *            Rwr_ManGetPractical( Rwr_Man_t * p );
 
-#ifdef __cplusplus
-}
-#endif
+
+
+ABC_NAMESPACE_HEADER_END
+
+
 
 #endif
 
diff --git a/src/opt/rwr/rwrDec.c b/src/opt/rwr/rwrDec.c
index 81c7e307..76d8ac51 100644
--- a/src/opt/rwr/rwrDec.c
+++ b/src/opt/rwr/rwrDec.c
@@ -21,6 +21,9 @@
 #include "rwr.h"
 #include "dec.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -66,7 +69,7 @@ void Rwr_ManPreprocess( Rwr_Man_t * p )
         }
     }
     // compute decomposition forms for each node and verify them
-    Vec_VecForEachEntry( p->vClasses, pNode, i, k )
+    Vec_VecForEachEntry( Rwr_Node_t *, p->vClasses, pNode, i, k )
     {
         pGraph = Rwr_NodePreprocess( p, pNode );
         pNode->pNext = (Rwr_Node_t *)pGraph;
@@ -148,3 +151,5 @@ Dec_Edge_t Rwr_TravCollect_rec( Rwr_Man_t * p, Rwr_Node_t * pNode, Dec_Graph_t *
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/rwr/rwrEva.c b/src/opt/rwr/rwrEva.c
index 42c370ab..8f0c1821 100644
--- a/src/opt/rwr/rwrEva.c
+++ b/src/opt/rwr/rwrEva.c
@@ -20,6 +20,10 @@
 
 #include "rwr.h"
 #include "dec.h"
+#include "ivy.h"
+
+ABC_NAMESPACE_IMPL_START
+
 
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
@@ -117,7 +121,7 @@ clk = clock();
 
         {
             int Counter = 0;
-            Vec_PtrForEachEntry( p->vFaninsCur, pFanin, i )
+            Vec_PtrForEachEntry( Abc_Obj_t *, p->vFaninsCur, pFanin, i )
                 if ( Abc_ObjFanoutNum(Abc_ObjRegular(pFanin)) == 1 )
                     Counter++;
             if ( Counter > 2 )
@@ -127,19 +131,19 @@ clk = clock();
 clk2 = clock();
 /*
         printf( "Considering: (" );
-        Vec_PtrForEachEntry( p->vFaninsCur, pFanin, i )
+        Vec_PtrForEachEntry( Abc_Obj_t *, p->vFaninsCur, pFanin, i )
             printf( "%d ", Abc_ObjFanoutNum(Abc_ObjRegular(pFanin)) );
         printf( ")\n" );
 */
         // mark the fanin boundary 
-        Vec_PtrForEachEntry( p->vFaninsCur, pFanin, i )
+        Vec_PtrForEachEntry( Abc_Obj_t *, p->vFaninsCur, pFanin, i )
             Abc_ObjRegular(pFanin)->vFanouts.nSize++;
 
         // label MFFC with current ID
         Abc_NtkIncrementTravId( pNode->pNtk );
         nNodesSaved = Abc_NodeMffcLabelAig( pNode );
         // unmark the fanin boundary
-        Vec_PtrForEachEntry( p->vFaninsCur, pFanin, i )
+        Vec_PtrForEachEntry( Abc_Obj_t *, p->vFaninsCur, pFanin, i )
             Abc_ObjRegular(pFanin)->vFanouts.nSize--;
 p->timeMffc += clock() - clk2;
 
@@ -159,7 +163,7 @@ p->timeEval += clock() - clk2;
             uTruthBest = 0xFFFF & *Cut_CutReadTruth(pCut);
             // collect fanins in the
             Vec_PtrClear( p->vFanins );
-            Vec_PtrForEachEntry( p->vFaninsCur, pFanin, i )
+            Vec_PtrForEachEntry( Abc_Obj_t *, p->vFaninsCur, pFanin, i )
                 Vec_PtrPush( p->vFanins, pFanin );
         }
     }
@@ -172,7 +176,7 @@ p->timeRes += clock() - clk;
     {
         printf( "Class %d  ", p->pMap[uTruthBest] );
         printf( "Gain = %d. Node %d : ", GainBest, pNode->Id );
-        Vec_PtrForEachEntry( p->vFanins, pFanin, i )
+        Vec_PtrForEachEntry( Abc_Obj_t *, p->vFanins, pFanin, i )
             printf( "%d ", Abc_ObjRegular(pFanin)->Id );
         Dec_GraphPrint( stdout, p->pGraph, NULL, NULL );
         printf( "\n" );
@@ -188,7 +192,7 @@ p->timeRes += clock() - clk;
         else
         {
             printf( "Node %d : ", pNode->Id );
-            Vec_PtrForEachEntry( p->vFanins, pFanin, i )
+            Vec_PtrForEachEntry( Abc_Obj_t *, p->vFanins, pFanin, i )
                 printf( "%d ", Abc_ObjRegular(pFanin)->Id );
             printf( "a" );
         }
@@ -203,11 +207,11 @@ p->timeRes += clock() - clk;
 */
 
     // copy the leaves
-    Vec_PtrForEachEntry( p->vFanins, pFanin, i )
-        Dec_GraphNode(p->pGraph, i)->pFunc = pFanin;
+    Vec_PtrForEachEntry( Abc_Obj_t *, p->vFanins, pFanin, i )
+        Dec_GraphNode((Dec_Graph_t *)p->pGraph, i)->pFunc = pFanin;
 /*
     printf( "(" );
-    Vec_PtrForEachEntry( p->vFanins, pFanin, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, p->vFanins, pFanin, i )
         printf( " %d", Abc_ObjRegular(pFanin)->vFanouts.nSize - 1 );
     printf( " )  " );
 */
@@ -228,7 +232,7 @@ p->timeRes += clock() - clk;
         printf( "Save = %d.  ", nNodesSaveCur );
         printf( "Add = %d.  ",  nNodesSaveCur-GainBest );
         printf( "GAIN = %d.  ", GainBest );
-        printf( "Cone = %d.  ", p->pGraph? Dec_GraphNodeNum(p->pGraph) : 0 );
+        printf( "Cone = %d.  ", p->pGraph? Dec_GraphNodeNum((Dec_Graph_t *)p->pGraph) : 0 );
         printf( "Class = %d.  ", p->pMap[uTruthBest] );
         printf( "\n" );
     }
@@ -258,17 +262,17 @@ Dec_Graph_t * Rwr_CutEvaluate( Rwr_Man_t * p, Abc_Obj_t * pRoot, Cut_Cut_t * pCu
     float CostBest;//, CostCur;
     // find the matching class of subgraphs
     uTruth = 0xFFFF & *Cut_CutReadTruth(pCut);
-    vSubgraphs = Vec_VecEntry( p->vClasses, p->pMap[uTruth] );
+    vSubgraphs = (Vec_Ptr_t *)Vec_VecEntry( p->vClasses, p->pMap[uTruth] );
     p->nSubgraphs += vSubgraphs->nSize;
     // determine the best subgraph
     GainBest = -1;
     CostBest = ABC_INFINITY;
-    Vec_PtrForEachEntry( vSubgraphs, pNode, i )
+    Vec_PtrForEachEntry( Rwr_Node_t *, vSubgraphs, pNode, i )
     {
         // get the current graph
         pGraphCur = (Dec_Graph_t *)pNode->pNext;
         // copy the leaves
-        Vec_PtrForEachEntry( vFaninsCur, pFanin, k )
+        Vec_PtrForEachEntry( Rwr_Node_t *, vFaninsCur, pFanin, k )
             Dec_GraphNode(pGraphCur, k)->pFunc = pFanin;
         // detect how many unlabeled nodes will be reused
         nNodesAdded = Dec_GraphToNetworkCount( pRoot, pGraphCur, nNodesSaved, LevelMax );
@@ -376,7 +380,7 @@ int Rwr_CutIsBoolean( Abc_Obj_t * pObj, Vec_Ptr_t * vLeaves )
 {
     Abc_Obj_t * pTemp;
     int i, RetValue;
-    Vec_PtrForEachEntry( vLeaves, pTemp, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vLeaves, pTemp, i )
     {
         pTemp = Abc_ObjRegular(pTemp);
         assert( !pTemp->fMarkA && !pTemp->fMarkB );
@@ -384,7 +388,7 @@ int Rwr_CutIsBoolean( Abc_Obj_t * pObj, Vec_Ptr_t * vLeaves )
     Rwr_CutIsBoolean_rec( Abc_ObjFanin0(pObj), vLeaves, 1 );
     Rwr_CutIsBoolean_rec( Abc_ObjFanin1(pObj), vLeaves, 0 );
     RetValue = 0;
-    Vec_PtrForEachEntry( vLeaves, pTemp, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vLeaves, pTemp, i )
     {
         pTemp = Abc_ObjRegular(pTemp);
         RetValue |= pTemp->fMarkA && pTemp->fMarkB;
@@ -451,7 +455,7 @@ int Rwr_CutCountNumNodes( Abc_Obj_t * pObj, Cut_Cut_t * pCut )
     for ( pCut = pCut->pNext; pCut; pCut = pCut->pNext )
         Rwr_CutCountNumNodes_rec( pObj, pCut, vNodes );
     // clean all nodes
-    Vec_PtrForEachEntry( vNodes, pObj, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pObj, i )
         pObj->fMarkC = 0;
     // delete and return
     Counter = Vec_PtrSize(vNodes);
@@ -477,7 +481,7 @@ int Rwr_NodeGetDepth_rec( Abc_Obj_t * pObj, Vec_Ptr_t * vLeaves )
     int i, Depth0, Depth1;
     if ( Abc_ObjIsCi(pObj) )
         return 0;
-    Vec_PtrForEachEntry( vLeaves, pLeaf, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vLeaves, pLeaf, i )
         if ( pObj == Abc_ObjRegular(pLeaf) )
             return 0;
     Depth0 = Rwr_NodeGetDepth_rec( Abc_ObjFanin0(pObj), vLeaves );
@@ -504,8 +508,8 @@ void Rwr_ScoresClean( Rwr_Man_t * p )
     int i, k;
     for ( i = 0; i < p->vClasses->nSize; i++ )
     {
-        vSubgraphs = Vec_VecEntry( p->vClasses, i );
-        Vec_PtrForEachEntry( vSubgraphs, pNode, k )
+        vSubgraphs = (Vec_Ptr_t *)Vec_VecEntry( p->vClasses, i );
+        Vec_PtrForEachEntry( Rwr_Node_t *, vSubgraphs, pNode, k )
             pNode->nScore = pNode->nGain = pNode->nAdded = 0;
     }
 }
@@ -557,8 +561,8 @@ void Rwr_ScoresReport( Rwr_Man_t * p )
     {
         Perm[i] = i;
         Gains[i] = 0;
-        vSubgraphs = Vec_VecEntry( p->vClasses, i );
-        Vec_PtrForEachEntry( vSubgraphs, pNode, k )
+        vSubgraphs = (Vec_Ptr_t *)Vec_VecEntry( p->vClasses, i );
+        Vec_PtrForEachEntry( Rwr_Node_t *, vSubgraphs, pNode, k )
             Gains[i] += pNode->nGain;
     }
     // sort the gains
@@ -570,13 +574,13 @@ void Rwr_ScoresReport( Rwr_Man_t * p )
         iNew = Perm[i];
         if ( Gains[iNew] == 0 )
             break;
-        vSubgraphs = Vec_VecEntry( p->vClasses, iNew );
+        vSubgraphs = (Vec_Ptr_t *)Vec_VecEntry( p->vClasses, iNew );
         printf( "CLASS %3d: Subgr = %3d. Total gain = %6d.  ", iNew, Vec_PtrSize(vSubgraphs), Gains[iNew] );
         uTruth = (unsigned)p->pMapInv[iNew];
         Extra_PrintBinary( stdout, &uTruth, 16 );
         printf( "  " );
         Ivy_TruthDsdComputePrint( (unsigned)p->pMapInv[iNew] | ((unsigned)p->pMapInv[iNew] << 16) );
-        Vec_PtrForEachEntry( vSubgraphs, pNode, k )
+        Vec_PtrForEachEntry( Rwr_Node_t *, vSubgraphs, pNode, k )
         {
             if ( pNode->nScore == 0 )
                 continue;
@@ -591,3 +595,5 @@ void Rwr_ScoresReport( Rwr_Man_t * p )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/rwr/rwrExp.c b/src/opt/rwr/rwrExp.c
index 543cae07..c4664fbf 100644
--- a/src/opt/rwr/rwrExp.c
+++ b/src/opt/rwr/rwrExp.c
@@ -20,6 +20,9 @@
 
 #include "rwr.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -149,7 +152,7 @@ void Rwt_Man4ExplorePrint()
     for ( i = 0; i < s_pManRwrExp4->nFuncs; i++ )
         if ( s_pManRwrExp4->pnCounts[i] > 0 )
         {
-            Extra_PrintHex( pFile, i, 4 );
+            Extra_PrintHex( pFile, (unsigned *)&i, 4 );
             fprintf( pFile, " %10d\n", s_pManRwrExp4->pnCounts[i] );
 //            fprintf( pFile, "%d ", i );
             CountWrite++;
@@ -275,7 +278,7 @@ void Rwt_Man5ExplorePrint()
         {
             assert( 0 );
         }
-        Extra_PrintHex( pFile, uTruth, 5 );
+        Extra_PrintHex( pFile, &uTruth, 5 );
         fprintf( pFile, " %10d\n", Counter );
     }
     fclose( pFile );
@@ -313,7 +316,7 @@ ABC_PRT( "Computing NPN classes", clock() - clk );
         {
             assert( 0 );
         }
-        Extra_PrintHex( pFile, uTruth, 5 );
+        Extra_PrintHex( pFile, &uTruth, 5 );
         fprintf( pFile, " %10d\n", Counter );
     }
     fclose( pFile );
@@ -329,3 +332,5 @@ ABC_PRT( "Computing NPN classes", clock() - clk );
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/rwr/rwrLib.c b/src/opt/rwr/rwrLib.c
index 1cdf350e..731871d0 100644
--- a/src/opt/rwr/rwrLib.c
+++ b/src/opt/rwr/rwrLib.c
@@ -20,6 +20,9 @@
 
 #include "rwr.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -49,8 +52,8 @@ void Rwr_ManPrecompute( Rwr_Man_t * p )
     int LevelOld = -1;
     int nNodes;
 
-    Vec_PtrForEachEntryStart( p->vForest, p0, i, 1 )
-    Vec_PtrForEachEntryStart( p->vForest, p1, k, 1 )
+    Vec_PtrForEachEntryStart( Rwr_Node_t *, p->vForest, p0, i, 1 )
+    Vec_PtrForEachEntryStart( Rwr_Node_t *, p->vForest, p1, k, 1 )
     {
         if ( LevelOld < (int)p0->Level )
         {
@@ -99,7 +102,7 @@ save :
     Rwr_ManIncTravId( p );
     k = 5;
     nNodes = 0;
-    Vec_PtrForEachEntryStart( p->vForest, p0, i, 5 )
+    Vec_PtrForEachEntryStart( Rwr_Node_t *, p->vForest, p0, i, 5 )
         if ( p0->uTruth == p->puCanons[p0->uTruth] )
         {
             Rwr_MarkUsed_rec( p, p0 );
@@ -108,7 +111,7 @@ save :
 
     // compact the array by throwing away non-canonical
     k = 5;
-    Vec_PtrForEachEntryStart( p->vForest, p0, i, 5 )
+    Vec_PtrForEachEntryStart( Rwr_Node_t *, p->vForest, p0, i, 5 )
         if ( p0->fUsed )
         {
             p->vForest->pArray[k] = p0;
@@ -350,7 +353,7 @@ void Rwr_ManIncTravId( Rwr_Man_t * p )
     int i;
     if ( p->nTravIds++ < 0x8FFFFFFF )
         return;
-    Vec_PtrForEachEntry( p->vForest, pNode, i )
+    Vec_PtrForEachEntry( Rwr_Node_t *, p->vForest, pNode, i )
         pNode->TravId = 0;
     p->nTravIds = 1;
 }
@@ -360,3 +363,5 @@ void Rwr_ManIncTravId( Rwr_Man_t * p )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/rwr/rwrMan.c b/src/opt/rwr/rwrMan.c
index e7d21164..ffc5fcae 100644
--- a/src/opt/rwr/rwrMan.c
+++ b/src/opt/rwr/rwrMan.c
@@ -22,6 +22,9 @@
 #include "main.h"
 #include "dec.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -41,7 +44,7 @@
   SeeAlso     []
 
 ***********************************************************************/
-Rwr_Man_t * Rwr_ManStart( bool fPrecompute )
+Rwr_Man_t * Rwr_ManStart( int  fPrecompute )
 {
     Dec_Man_t * pManDec;
     Rwr_Man_t * p;
@@ -50,7 +53,7 @@ clk = clock();
     p = ABC_ALLOC( Rwr_Man_t, 1 );
     memset( p, 0, sizeof(Rwr_Man_t) );
     p->nFuncs = (1<<16);
-    pManDec   = Abc_FrameReadManDec();
+    pManDec   = (Dec_Man_t *)Abc_FrameReadManDec();
     p->puCanons = pManDec->puCanons; 
     p->pPhases  = pManDec->pPhases; 
     p->pPerms   = pManDec->pPerms; 
@@ -109,7 +112,7 @@ void Rwr_ManStop( Rwr_Man_t * p )
     {
         Rwr_Node_t * pNode;
         int i, k;
-        Vec_VecForEachEntry( p->vClasses, pNode, i, k )
+        Vec_VecForEachEntry( Rwr_Node_t *, p->vClasses, pNode, i, k )
             Dec_GraphFree( (Dec_Graph_t *)pNode->pNext );
     }
     if ( p->vClasses )  Vec_VecFree( p->vClasses );
@@ -316,3 +319,5 @@ void Rwr_Precompute()
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/rwr/rwrPrint.c b/src/opt/rwr/rwrPrint.c
index 82ad2a90..11a084d3 100644
--- a/src/opt/rwr/rwrPrint.c
+++ b/src/opt/rwr/rwrPrint.c
@@ -20,6 +20,9 @@
 
 #include "rwr.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -206,9 +209,9 @@ void Rwr_NodePrint( FILE * pFile, Rwr_Man_t * p, Rwr_Node_t * pNode )
 {
     unsigned uTruth;
     fprintf( pFile, "%5d : ", pNode->Id );
-    Extra_PrintHex( pFile, pNode->uTruth, 4 );
-    fprintf( pFile, " tt=" );
     uTruth = pNode->uTruth;
+    Extra_PrintHex( pFile, &uTruth, 4 );
+    fprintf( pFile, " tt=" );
     Extra_PrintBinary( pFile, &uTruth, 16 );
 //    fprintf( pFile, " cn=", pNode->Id );
 //    uTruth = p->puCanons[pNode->uTruth];
@@ -264,3 +267,5 @@ void Rwr_ManPrint( Rwr_Man_t * p )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/rwr/rwrTemp.c b/src/opt/rwr/rwrTemp.c
index 3ffbd408..6a670c3a 100644
--- a/src/opt/rwr/rwrTemp.c
+++ b/src/opt/rwr/rwrTemp.c
@@ -20,6 +20,9 @@
 
 #include "rwr.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -106,7 +109,7 @@ void Rwr_Temp()
         for ( k = 0; k < 32; k++ )
             if ( uTruth & (1 << k) )
             {
-                Extra_PrintBinary( pFile, &k, 5 );
+                Extra_PrintBinary( pFile, (unsigned *)&k, 5 );
                 fprintf( pFile, " 1\n" );
             }
     }
@@ -119,3 +122,5 @@ void Rwr_Temp()
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/rwr/rwrUtil.c b/src/opt/rwr/rwrUtil.c
index 8da3b6eb..7a836d63 100644
--- a/src/opt/rwr/rwrUtil.c
+++ b/src/opt/rwr/rwrUtil.c
@@ -20,18 +20,393 @@
 
 #include "rwr.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
 
 // precomputed data
-#ifdef _WIN32
-unsigned short s_RwrPracticalClasses[];
-unsigned short s_RwtAigSubgraphs[];
-#else
-static unsigned short s_RwrPracticalClasses[];
-static unsigned short s_RwtAigSubgraphs[];
-#endif
+// the following 135 practical NPN classes of 4-variable functions were computed
+// by considering all 4-input cuts appearing in IWLS, MCNC, and ISCAS benchmarks
+static unsigned short s_RwrPracticalClasses[] =
+{
+    0x0000, 0x0001, 0x0003, 0x0006, 0x0007, 0x000f, 0x0016, 0x0017, 0x0018, 0x0019, 0x001b,
+    0x001e, 0x001f, 0x003c, 0x003d, 0x003f, 0x0069, 0x006b, 0x006f, 0x007e, 0x007f, 0x00ff,
+    0x0116, 0x0118, 0x0119, 0x011a, 0x011b, 0x011e, 0x011f, 0x012c, 0x012d, 0x012f, 0x013c,
+    0x013d, 0x013e, 0x013f, 0x0168, 0x0169, 0x016f, 0x017f, 0x0180, 0x0181, 0x0182, 0x0183,
+    0x0186, 0x0189, 0x018b, 0x018f, 0x0198, 0x0199, 0x019b, 0x01a8, 0x01a9, 0x01aa, 0x01ab,
+    0x01ac, 0x01ad, 0x01ae, 0x01af, 0x01bf, 0x01e9, 0x01ea, 0x01eb, 0x01ee, 0x01ef, 0x01fe,
+    0x033c, 0x033d, 0x033f, 0x0356, 0x0357, 0x0358, 0x0359, 0x035a, 0x035b, 0x035f, 0x0368,
+    0x0369, 0x036c, 0x036e, 0x037d, 0x03c0, 0x03c1, 0x03c3, 0x03c7, 0x03cf, 0x03d4, 0x03d5,
+    0x03d7, 0x03d8, 0x03d9, 0x03dc, 0x03dd, 0x03de, 0x03fc, 0x0660, 0x0661, 0x0666, 0x0669,
+    0x066f, 0x0676, 0x067e, 0x0690, 0x0696, 0x0697, 0x069f, 0x06b1, 0x06b6, 0x06f0, 0x06f2,
+    0x06f6, 0x06f9, 0x0776, 0x0778, 0x07b0, 0x07b1, 0x07b4, 0x07bc, 0x07f0, 0x07f2, 0x07f8,
+    0x0ff0, 0x1683, 0x1696, 0x1698, 0x169e, 0x16e9, 0x178e, 0x17e8, 0x18e7, 0x19e6, 0x1be4,
+    0x1ee1, 0x3cc3, 0x6996, 0x0000
+};
+
+static unsigned short s_RwtAigSubgraphs[] =
+{
+    0x0008,0x0002, 0x000a,0x0002, 0x0008,0x0003, 0x000a,0x0003, 0x0009,0x0002,
+    0x000c,0x0002, 0x000e,0x0002, 0x000c,0x0003, 0x000e,0x0003, 0x000d,0x0002,
+    0x000c,0x0004, 0x000e,0x0004, 0x000c,0x0005, 0x000e,0x0005, 0x000d,0x0004,
+    0x0010,0x0002, 0x0012,0x0002, 0x0010,0x0003, 0x0012,0x0003, 0x0011,0x0002,
+    0x0010,0x0004, 0x0012,0x0004, 0x0010,0x0005, 0x0012,0x0005, 0x0011,0x0004,
+    0x0010,0x0006, 0x0012,0x0006, 0x0010,0x0007, 0x0012,0x0007, 0x0011,0x0006,
+    0x0016,0x0005, 0x0014,0x0006, 0x0016,0x0006, 0x0014,0x0007, 0x0016,0x0007,
+    0x0015,0x0006, 0x0014,0x0008, 0x0016,0x0008, 0x0014,0x0009, 0x0016,0x0009,
+    0x0015,0x0008, 0x0018,0x0006, 0x001a,0x0006, 0x0018,0x0007, 0x001a,0x0007,
+    0x0019,0x0006, 0x0018,0x0009, 0x001a,0x0009, 0x0019,0x0008, 0x001e,0x0005,
+    0x001c,0x0006, 0x001e,0x0006, 0x001c,0x0007, 0x001e,0x0007, 0x001d,0x0006,
+    0x001c,0x0008, 0x001e,0x0008, 0x001c,0x0009, 0x001e,0x0009, 0x001d,0x0008,
+    0x0020,0x0006, 0x0022,0x0006, 0x0020,0x0007, 0x0022,0x0007, 0x0021,0x0006,
+    0x0020,0x0008, 0x0022,0x0008, 0x0020,0x0009, 0x0022,0x0009, 0x0021,0x0008,
+    0x0024,0x0006, 0x0026,0x0006, 0x0024,0x0007, 0x0026,0x0007, 0x0025,0x0006,
+    0x0026,0x0008, 0x0024,0x0009, 0x0026,0x0009, 0x0025,0x0008, 0x0028,0x0004,
+    0x002a,0x0004, 0x0028,0x0005, 0x002a,0x0007, 0x0028,0x0008, 0x002a,0x0009,
+    0x0029,0x0008, 0x002a,0x000b, 0x0029,0x000a, 0x002a,0x000f, 0x0029,0x000e,
+    0x002a,0x0011, 0x002a,0x0013, 0x002c,0x0004, 0x002e,0x0004, 0x002c,0x0005,
+    0x002c,0x0009, 0x002e,0x0009, 0x002d,0x0008, 0x002d,0x000c, 0x002e,0x000f,
+    0x002e,0x0011, 0x002e,0x0012, 0x0030,0x0004, 0x0032,0x0007, 0x0032,0x0009,
+    0x0031,0x0008, 0x0032,0x000b, 0x0032,0x000d, 0x0032,0x000f, 0x0031,0x000e,
+    0x0032,0x0013, 0x0034,0x0004, 0x0036,0x0004, 0x0034,0x0005, 0x0036,0x0005,
+    0x0035,0x0004, 0x0036,0x0008, 0x0034,0x0009, 0x0036,0x0009, 0x0035,0x0008,
+    0x0036,0x000b, 0x0036,0x000d, 0x0036,0x0011, 0x0035,0x0010, 0x0036,0x0013,
+    0x0038,0x0004, 0x0039,0x0004, 0x0038,0x0009, 0x003a,0x0009, 0x0039,0x0008,
+    0x0038,0x000b, 0x003a,0x000b, 0x003a,0x000d, 0x003a,0x0011, 0x003a,0x0012,
+    0x0038,0x0013, 0x003a,0x0013, 0x003c,0x0002, 0x003e,0x0002, 0x003c,0x0003,
+    0x003e,0x0005, 0x003e,0x0007, 0x003c,0x0008, 0x003e,0x0008, 0x003c,0x0009,
+    0x003e,0x0009, 0x003d,0x0008, 0x003e,0x000d, 0x003e,0x0011, 0x003e,0x0013,
+    0x003e,0x0017, 0x003e,0x001b, 0x003e,0x001d, 0x0040,0x0002, 0x0042,0x0002,
+    0x0042,0x0005, 0x0041,0x0006, 0x0042,0x0008, 0x0041,0x0008, 0x0042,0x000d,
+    0x0042,0x0011, 0x0042,0x0015, 0x0042,0x0019, 0x0042,0x001b, 0x0042,0x001c,
+    0x0041,0x001c, 0x0044,0x0002, 0x0046,0x0003, 0x0045,0x0004, 0x0046,0x0007,
+    0x0045,0x0008, 0x0046,0x000b, 0x0046,0x000f, 0x0046,0x0013, 0x0045,0x0012,
+    0x0046,0x0017, 0x0046,0x001b, 0x0046,0x0021, 0x0048,0x0002, 0x004a,0x0002,
+    0x0048,0x0003, 0x004a,0x0003, 0x0049,0x0002, 0x0048,0x0008, 0x004a,0x0008,
+    0x0048,0x0009, 0x004a,0x0009, 0x0049,0x0008, 0x004a,0x000b, 0x004a,0x000f,
+    0x004a,0x0011, 0x004a,0x0012, 0x004a,0x0013, 0x004a,0x0015, 0x004a,0x0019,
+    0x004a,0x001b, 0x004a,0x001d, 0x004c,0x0002, 0x004c,0x0003, 0x004d,0x0002,
+    0x004c,0x0008, 0x004e,0x0008, 0x004c,0x0009, 0x004e,0x0009, 0x004d,0x0008,
+    0x004c,0x000b, 0x004e,0x000b, 0x004c,0x000f, 0x004e,0x000f, 0x004e,0x0011,
+    0x004c,0x0012, 0x004c,0x0013, 0x004e,0x0013, 0x004e,0x0015, 0x004c,0x0017,
+    0x004e,0x0019, 0x004c,0x001b, 0x004e,0x001b, 0x004c,0x001c, 0x004c,0x001d,
+    0x004e,0x001d, 0x0050,0x0004, 0x0052,0x0004, 0x0050,0x0006, 0x0052,0x0009,
+    0x0052,0x000d, 0x0052,0x000f, 0x0052,0x0013, 0x0052,0x0017, 0x0052,0x0019,
+    0x0052,0x001d, 0x0052,0x001f, 0x0052,0x0021, 0x0052,0x0023, 0x0052,0x0024,
+    0x0052,0x0025, 0x0051,0x0024, 0x0052,0x0027, 0x0054,0x0004, 0x0056,0x0004,
+    0x0054,0x0005, 0x0056,0x0006, 0x0054,0x0007, 0x0056,0x0011, 0x0056,0x001b,
+    0x0056,0x001e, 0x0054,0x001f, 0x0056,0x001f, 0x0056,0x0020, 0x0054,0x0021,
+    0x0055,0x0020, 0x0056,0x0024, 0x0054,0x0025, 0x0056,0x0025, 0x0055,0x0024,
+    0x0054,0x0027, 0x0056,0x0027, 0x0055,0x0026, 0x005a,0x0007, 0x005a,0x0009,
+    0x005a,0x000b, 0x005a,0x0015, 0x005a,0x001f, 0x0059,0x0020, 0x0058,0x0024,
+    0x005a,0x0024, 0x005a,0x0027, 0x0059,0x0026, 0x005c,0x0004, 0x005e,0x0004,
+    0x005c,0x0005, 0x005e,0x0006, 0x005c,0x0007, 0x005d,0x0006, 0x005e,0x000d,
+    0x005e,0x0013, 0x005e,0x0017, 0x005c,0x001f, 0x005d,0x001e, 0x005e,0x0020,
+    0x005e,0x0021, 0x005e,0x0022, 0x005e,0x0023, 0x005c,0x0024, 0x005e,0x0024,
+    0x005c,0x0025, 0x005e,0x0025, 0x005d,0x0024, 0x005e,0x0026, 0x005e,0x0027,
+    0x0062,0x0004, 0x0061,0x0004, 0x0062,0x0006, 0x0061,0x0006, 0x0060,0x000f,
+    0x0060,0x0013, 0x0062,0x0013, 0x0060,0x0019, 0x0062,0x001c, 0x0060,0x001d,
+    0x0062,0x001d, 0x0062,0x001f, 0x0060,0x0021, 0x0060,0x0023, 0x0062,0x0024,
+    0x0060,0x0027, 0x0061,0x0026, 0x0064,0x0002, 0x0066,0x0002, 0x0064,0x0006,
+    0x0066,0x0007, 0x0066,0x0009, 0x0066,0x000d, 0x0066,0x0013, 0x0066,0x0015,
+    0x0066,0x0017, 0x0066,0x0019, 0x0066,0x001a, 0x0065,0x001a, 0x0066,0x001f,
+    0x0066,0x0023, 0x0066,0x0027, 0x0066,0x002f, 0x0066,0x0030, 0x006a,0x0002,
+    0x0068,0x0003, 0x0068,0x0006, 0x006a,0x0006, 0x006a,0x0011, 0x0068,0x0016,
+    0x0068,0x0017, 0x006a,0x0017, 0x006a,0x001a, 0x006a,0x001b, 0x006a,0x0025,
+    0x006a,0x002d, 0x006e,0x0003, 0x006e,0x0007, 0x006e,0x0009, 0x006e,0x000b,
+    0x006e,0x0015, 0x006e,0x0016, 0x006e,0x0017, 0x006c,0x001a, 0x006e,0x001a,
+    0x006e,0x001f, 0x006e,0x002b, 0x006e,0x0035, 0x0070,0x0002, 0x0070,0x0003,
+    0x0072,0x0006, 0x0070,0x0007, 0x0071,0x0006, 0x0072,0x000b, 0x0072,0x000f,
+    0x0072,0x0013, 0x0070,0x0015, 0x0071,0x0014, 0x0072,0x0017, 0x0072,0x0018,
+    0x0070,0x0019, 0x0072,0x0019, 0x0070,0x001a, 0x0070,0x001b, 0x0072,0x001b,
+    0x0071,0x001a, 0x0072,0x0021, 0x0072,0x0029, 0x0076,0x0002, 0x0076,0x0003,
+    0x0075,0x0002, 0x0076,0x0006, 0x0074,0x0007, 0x0076,0x0007, 0x0075,0x0006,
+    0x0076,0x000d, 0x0076,0x0011, 0x0076,0x0013, 0x0075,0x0014, 0x0076,0x0019,
+    0x0076,0x001a, 0x0076,0x001b, 0x0075,0x001c, 0x0074,0x0023, 0x0075,0x0022,
+    0x0074,0x0026, 0x0076,0x0026, 0x0074,0x0027, 0x0076,0x002b, 0x0076,0x002f,
+    0x0078,0x0002, 0x0078,0x0004, 0x007a,0x0004, 0x007a,0x0005, 0x0079,0x0004,
+    0x007a,0x0009, 0x007a,0x000a, 0x007a,0x000b, 0x007a,0x000d, 0x007a,0x000f,
+    0x007a,0x0010, 0x007a,0x0011, 0x007a,0x0012, 0x007a,0x0013, 0x007a,0x0017,
+    0x007a,0x001b, 0x007a,0x0021, 0x007a,0x0027, 0x007a,0x002b, 0x007a,0x002f,
+    0x007a,0x0030, 0x0079,0x0034, 0x007a,0x0039, 0x007a,0x003a, 0x007e,0x0002,
+    0x007c,0x0004, 0x007e,0x0004, 0x007e,0x000c, 0x007c,0x000d, 0x007e,0x0011,
+    0x007e,0x0013, 0x007e,0x001b, 0x007e,0x0025, 0x007e,0x002d, 0x007e,0x0037,
+    0x0082,0x0003, 0x0082,0x0005, 0x0082,0x0009, 0x0082,0x000b, 0x0080,0x0010,
+    0x0082,0x0010, 0x0082,0x0012, 0x0082,0x0015, 0x0082,0x001f, 0x0082,0x002b,
+    0x0082,0x0035, 0x0082,0x0039, 0x0082,0x003f, 0x0084,0x0002, 0x0086,0x0002,
+    0x0084,0x0003, 0x0086,0x0003, 0x0085,0x0002, 0x0086,0x0004, 0x0084,0x0005,
+    0x0085,0x0004, 0x0086,0x000a, 0x0084,0x000b, 0x0085,0x000a, 0x0086,0x000d,
+    0x0086,0x000e, 0x0086,0x000f, 0x0084,0x0010, 0x0084,0x0011, 0x0086,0x0011,
+    0x0085,0x0010, 0x0084,0x0012, 0x0084,0x0013, 0x0086,0x0013, 0x0085,0x0012,
+    0x0086,0x0019, 0x0086,0x0023, 0x0086,0x0029, 0x0086,0x0033, 0x0086,0x0039,
+    0x008a,0x0003, 0x0089,0x0002, 0x0088,0x0004, 0x008a,0x0004, 0x0088,0x0005,
+    0x0089,0x0004, 0x008a,0x000b, 0x008a,0x0010, 0x0088,0x0011, 0x008a,0x0011,
+    0x0089,0x0010, 0x0088,0x0012, 0x008a,0x0012, 0x0089,0x0012, 0x008a,0x0017,
+    0x008a,0x001b, 0x0089,0x0020, 0x008a,0x0025, 0x0088,0x0027, 0x008a,0x002b,
+    0x008a,0x002f, 0x008a,0x0039, 0x0088,0x003a, 0x008d,0x0044, 0x0092,0x0009,
+    0x0092,0x0025, 0x0092,0x0029, 0x0092,0x002d, 0x0092,0x0033, 0x0092,0x0037,
+    0x0092,0x003d, 0x0092,0x0041, 0x0095,0x0002, 0x0095,0x0004, 0x0095,0x0010,
+    0x0095,0x0012, 0x0096,0x0021, 0x0096,0x0029, 0x0095,0x002e, 0x0096,0x0030,
+    0x0096,0x0033, 0x0096,0x003a, 0x0096,0x0043, 0x009a,0x0008, 0x009a,0x0009,
+    0x0099,0x0008, 0x009a,0x0011, 0x009a,0x0023, 0x009a,0x0033, 0x009a,0x003d,
+    0x009a,0x0044, 0x009a,0x0045, 0x0099,0x0044, 0x009d,0x0002, 0x009e,0x0008,
+    0x009c,0x0009, 0x009e,0x0009, 0x009d,0x0008, 0x009e,0x0011, 0x009d,0x0010,
+    0x009e,0x001f, 0x009e,0x003f, 0x00a0,0x0009, 0x00a0,0x0011, 0x00a2,0x0030,
+    0x00a2,0x0033, 0x00a6,0x0006, 0x00a6,0x0007, 0x00a6,0x0011, 0x00a6,0x0044,
+    0x00a6,0x004b, 0x00aa,0x0007, 0x00aa,0x0015, 0x00ae,0x0006, 0x00ae,0x0011,
+    0x00ae,0x001b, 0x00ae,0x0025, 0x00ae,0x003d, 0x00ae,0x0041, 0x00ae,0x0043,
+    0x00ae,0x0045, 0x00b2,0x0006, 0x00b0,0x0007, 0x00b1,0x0006, 0x00b2,0x0017,
+    0x00b1,0x0016, 0x00b0,0x0019, 0x00b2,0x0021, 0x00b2,0x003d, 0x00b5,0x004a,
+    0x00ba,0x0009, 0x00ba,0x000f, 0x00bc,0x0009, 0x00be,0x0009, 0x00be,0x000f,
+    0x00bd,0x000e, 0x00be,0x0017, 0x00c2,0x0009, 0x00c2,0x0019, 0x00c2,0x001f,
+    0x00c2,0x0033, 0x00c6,0x0009, 0x00c5,0x000e, 0x00c6,0x0015, 0x00c6,0x0023,
+    0x00c4,0x002d, 0x00c6,0x002f, 0x00c5,0x002e, 0x00c6,0x0045, 0x00ce,0x0007,
+    0x00ce,0x0021, 0x00ce,0x0023, 0x00ce,0x0025, 0x00ce,0x0027, 0x00ce,0x0033,
+    0x00ce,0x003d, 0x00d2,0x0006, 0x00d0,0x0015, 0x00d0,0x001b, 0x00d2,0x001b,
+    0x00d1,0x001a, 0x00d0,0x001f, 0x00d2,0x0025, 0x00d1,0x0024, 0x00d2,0x0037,
+    0x00d2,0x0041, 0x00d2,0x0045, 0x00d9,0x0044, 0x00e1,0x0004, 0x00e2,0x000d,
+    0x00e2,0x0021, 0x00e0,0x003a, 0x00e6,0x003d, 0x00e6,0x0061, 0x00e6,0x0067,
+    0x00e9,0x0004, 0x00ea,0x0008, 0x00ea,0x0009, 0x00ea,0x0039, 0x00e9,0x0038,
+    0x00ea,0x003f, 0x00ec,0x000d, 0x00ee,0x000d, 0x00ee,0x0037, 0x00f2,0x003d,
+    0x00f2,0x0062, 0x00f5,0x0002, 0x00fa,0x0017, 0x00fa,0x003d, 0x00fe,0x0006,
+    0x00fd,0x0006, 0x00fc,0x0015, 0x00fe,0x001b, 0x00fc,0x0025, 0x00fe,0x0025,
+    0x00fd,0x0024, 0x00fe,0x0041, 0x00fe,0x004d, 0x00fd,0x004e, 0x0101,0x0014,
+    0x0106,0x004d, 0x010a,0x0009, 0x010a,0x000b, 0x0109,0x000a, 0x010a,0x004f,
+    0x010a,0x0058, 0x010e,0x0008, 0x010c,0x0009, 0x010e,0x0009, 0x010d,0x0008,
+    0x010e,0x000b, 0x010e,0x002b, 0x010d,0x002a, 0x010e,0x0035, 0x010e,0x003d,
+    0x010e,0x003f, 0x010e,0x0049, 0x010e,0x0057, 0x010d,0x0056, 0x010d,0x0058,
+    0x0111,0x0004, 0x0111,0x0006, 0x0110,0x0009, 0x0112,0x0009, 0x0111,0x0008,
+    0x0112,0x002f, 0x0110,0x0035, 0x0110,0x0037, 0x0112,0x0039, 0x0112,0x003d,
+    0x0112,0x003f, 0x0112,0x0045, 0x0111,0x0044, 0x0112,0x004b, 0x0112,0x0059,
+    0x0112,0x0069, 0x0112,0x007f, 0x0116,0x0009, 0x0115,0x0008, 0x0114,0x000b,
+    0x0116,0x000b, 0x0116,0x0058, 0x011a,0x0015, 0x011a,0x001f, 0x011a,0x002b,
+    0x011a,0x003f, 0x011a,0x0049, 0x011a,0x0085, 0x011e,0x0007, 0x011e,0x0019,
+    0x011e,0x001b, 0x011e,0x0023, 0x011e,0x0027, 0x011e,0x002f, 0x011e,0x0043,
+    0x011e,0x004b, 0x011e,0x004e, 0x011e,0x004f, 0x011e,0x005f, 0x011e,0x0061,
+    0x011e,0x0065, 0x011e,0x0083, 0x0122,0x0006, 0x0120,0x0007, 0x0122,0x0007,
+    0x0121,0x0006, 0x0122,0x0049, 0x0121,0x004e, 0x0122,0x008f, 0x0125,0x0004,
+    0x0124,0x0007, 0x0125,0x0006, 0x0124,0x001b, 0x0126,0x001b, 0x0126,0x0045,
+    0x0126,0x0087, 0x0128,0x0007, 0x0129,0x0006, 0x012a,0x0019, 0x012a,0x003d,
+    0x012a,0x0051, 0x012a,0x0065, 0x012a,0x0083, 0x012d,0x005a, 0x0132,0x0009,
+    0x0132,0x008f, 0x0134,0x0009, 0x0135,0x003e, 0x013a,0x003d, 0x013a,0x0044,
+    0x0139,0x0044, 0x013e,0x0009, 0x013d,0x0008, 0x013c,0x003d, 0x013c,0x0044,
+    0x013c,0x0053, 0x013e,0x008f, 0x013e,0x0095, 0x0142,0x0044, 0x0142,0x0097,
+    0x0142,0x009e, 0x0144,0x0007, 0x0148,0x0015, 0x0148,0x001c, 0x0148,0x001f,
+    0x0148,0x0026, 0x0149,0x0086, 0x014d,0x0006, 0x014e,0x0044, 0x014d,0x0048,
+    0x014e,0x009e, 0x0152,0x0009, 0x0151,0x00a6, 0x0155,0x0030, 0x015d,0x003a,
+    0x0162,0x009e, 0x0164,0x000f, 0x0164,0x0013, 0x0169,0x000e, 0x0174,0x0009,
+    0x0179,0x0008, 0x0180,0x0009, 0x0181,0x0044, 0x0186,0x0044, 0x0185,0x0044,
+    0x018a,0x0068, 0x0195,0x004e, 0x01a6,0x0009, 0x01a5,0x0008, 0x01b1,0x003a,
+    0x01c4,0x0029, 0x01c4,0x0030, 0x01ca,0x008f, 0x01ca,0x0095, 0x01cc,0x0029,
+    0x01cc,0x0033, 0x01ce,0x003d, 0x01d6,0x00b2, 0x01d8,0x0009, 0x01d9,0x002a,
+    0x01d9,0x0056, 0x01d9,0x00a4, 0x01dd,0x003a, 0x01e2,0x00b2, 0x01e6,0x0013,
+    0x01e6,0x009f, 0x01e6,0x00ba, 0x01e6,0x00c0, 0x01e6,0x00d3, 0x01e6,0x00d5,
+    0x01e6,0x00e5, 0x01e8,0x0005, 0x01f2,0x0013, 0x01f2,0x0095, 0x01f2,0x009f,
+    0x01f2,0x00ba, 0x01f2,0x00c0, 0x01f2,0x00d3, 0x0202,0x008f, 0x0202,0x0095,
+    0x0202,0x00f3, 0x0202,0x00f9, 0x020a,0x0044, 0x0209,0x00b4, 0x020e,0x0009,
+    0x020d,0x0008, 0x020c,0x003d, 0x020c,0x0044, 0x020c,0x0053, 0x020e,0x008f,
+    0x020e,0x0095, 0x020c,0x00b1, 0x020e,0x00f3, 0x020e,0x00f9, 0x0210,0x0013,
+    0x0211,0x0024, 0x0210,0x0026, 0x0219,0x0004, 0x021e,0x008f, 0x021e,0x0095,
+    0x0221,0x003a, 0x0230,0x0009, 0x0236,0x0009, 0x0234,0x0029, 0x0234,0x0030,
+    0x0234,0x0033, 0x0234,0x003a, 0x0234,0x003d, 0x0234,0x0044, 0x0235,0x00a6,
+    0x023a,0x0009, 0x023d,0x003a, 0x0245,0x0044, 0x0249,0x003a, 0x024e,0x009e,
+    0x024e,0x0106, 0x0251,0x0026, 0x0258,0x0013, 0x0259,0x0024, 0x0258,0x0061,
+    0x0259,0x0086, 0x0258,0x00c7, 0x0258,0x00df, 0x0259,0x00ec, 0x0258,0x00fc,
+    0x025d,0x0024, 0x025d,0x00de, 0x0260,0x00f6, 0x0268,0x0009, 0x0269,0x0044,
+    0x0268,0x00f3, 0x0268,0x00f9, 0x026d,0x003a, 0x0270,0x0068, 0x0275,0x003a,
+    0x027a,0x0044, 0x0279,0x0044, 0x027e,0x007e, 0x0281,0x0044, 0x0285,0x0008,
+    0x028d,0x0006, 0x028d,0x00d2, 0x0295,0x00cc, 0x0296,0x00f6, 0x0295,0x00f8,
+    0x0299,0x0030, 0x029e,0x007e, 0x029d,0x0080, 0x02a6,0x008f, 0x02a6,0x0095,
+    0x02aa,0x0029, 0x02aa,0x0030, 0x02b5,0x0008, 0x02b9,0x003a, 0x02bd,0x0004,
+    0x02bd,0x00fc, 0x02c2,0x00b2, 0x02c1,0x00b4, 0x02c4,0x0029, 0x02c8,0x0029,
+    0x02c8,0x0033, 0x02ca,0x003d, 0x02ce,0x0029, 0x02ce,0x0030, 0x02d2,0x0068,
+    0x02d1,0x006a, 0x02d5,0x006a, 0x02d9,0x0008, 0x02de,0x012c, 0x02e2,0x012c,
+    0x02e4,0x0009, 0x02e5,0x002a, 0x02e5,0x0056, 0x02e5,0x012c, 0x02ea,0x0029,
+    0x02ea,0x0030, 0x02e9,0x0030, 0x02ec,0x0029, 0x02ec,0x0030, 0x02ee,0x012c,
+    0x02f1,0x0068, 0x02f1,0x00b2, 0x02f1,0x0108, 0x02f1,0x012c, 0x02f6,0x0013,
+    0x02f6,0x0015, 0x02f6,0x001f, 0x02f6,0x0030, 0x02f6,0x0065, 0x02f6,0x0067,
+    0x02f6,0x009f, 0x02f6,0x00b6, 0x02f6,0x00b9, 0x02f6,0x00c0, 0x02f6,0x00cf,
+    0x02f6,0x0107, 0x02f6,0x010b, 0x02f6,0x010f, 0x02f6,0x0115, 0x02f6,0x012d,
+    0x02f6,0x0134, 0x02f6,0x0153, 0x02f6,0x0171, 0x02f6,0x0176, 0x02f8,0x0003,
+    0x02fa,0x017b, 0x02fc,0x00ba, 0x02fc,0x00d3, 0x0302,0x0013, 0x0302,0x001f,
+    0x0302,0x0030, 0x0302,0x005d, 0x0302,0x0065, 0x0302,0x0067, 0x0302,0x0099,
+    0x0302,0x009f, 0x0302,0x00ad, 0x0302,0x00b9, 0x0302,0x00c0, 0x0302,0x00cf,
+    0x0301,0x00d2, 0x0301,0x00fe, 0x0302,0x0107, 0x0302,0x010b, 0x0302,0x010f,
+    0x0302,0x0117, 0x0302,0x0134, 0x0302,0x0153, 0x0302,0x0157, 0x0302,0x0176,
+    0x0306,0x0029, 0x0308,0x00b2, 0x0309,0x00dc, 0x030d,0x00f8, 0x0312,0x00f3,
+    0x0318,0x007e, 0x031d,0x0080, 0x0321,0x0008, 0x0321,0x0094, 0x0326,0x017b,
+    0x0326,0x0181, 0x0329,0x012e, 0x032a,0x017b, 0x032a,0x0181, 0x032e,0x008f,
+    0x032e,0x0095, 0x032e,0x00f3, 0x032e,0x00f9, 0x0332,0x0009, 0x0331,0x0008,
+    0x0330,0x003d, 0x0330,0x0044, 0x0330,0x0053, 0x0332,0x008f, 0x0332,0x0095,
+    0x0330,0x00b1, 0x0332,0x00f3, 0x0332,0x00f9, 0x0330,0x0127, 0x0332,0x017b,
+    0x0332,0x0181, 0x033c,0x0013, 0x033c,0x001c, 0x033d,0x0086, 0x033d,0x00ec,
+    0x033d,0x0172, 0x033e,0x019d, 0x0345,0x0002, 0x0344,0x008f, 0x0344,0x00f3,
+    0x034d,0x0030, 0x0352,0x0033, 0x0354,0x0029, 0x0354,0x0030, 0x035a,0x0009,
+    0x035a,0x017b, 0x035a,0x019b, 0x035a,0x01a2, 0x035e,0x0181, 0x0360,0x0009,
+    0x0366,0x0009, 0x0364,0x0029, 0x0364,0x0030, 0x0364,0x0033, 0x0364,0x003a,
+    0x0364,0x003d, 0x0364,0x0044, 0x0369,0x0030, 0x0370,0x0029, 0x0370,0x0030,
+    0x0376,0x0033, 0x037a,0x0009, 0x037a,0x019b, 0x037a,0x01a2, 0x037c,0x0009,
+    0x0382,0x0181, 0x0386,0x0009, 0x0384,0x0029, 0x0384,0x0030, 0x0384,0x0033,
+    0x0384,0x003a, 0x0384,0x003d, 0x0384,0x0044, 0x038a,0x0044, 0x038a,0x009e,
+    0x038a,0x0106, 0x038a,0x0198, 0x038d,0x010e, 0x038d,0x0152, 0x038d,0x0158,
+    0x0392,0x009e, 0x0392,0x0106, 0x0392,0x0198, 0x0395,0x0086, 0x0395,0x009a,
+    0x0395,0x00ec, 0x0395,0x0172, 0x0398,0x014e, 0x0398,0x0175, 0x0398,0x018d,
+    0x039c,0x0023, 0x039c,0x0027, 0x039c,0x00ef, 0x039c,0x0139, 0x039c,0x0168,
+    0x03a0,0x0019, 0x03a0,0x001d, 0x03a0,0x0023, 0x03a0,0x0027, 0x03a1,0x004e,
+    0x03a4,0x0162, 0x03a4,0x0183, 0x03a8,0x0013, 0x03a8,0x0027, 0x03a8,0x0133,
+    0x03a8,0x0148, 0x03a8,0x0181, 0x03ac,0x0013, 0x03ac,0x0027, 0x03b0,0x017b,
+    0x03b0,0x0181, 0x03b4,0x004b, 0x03b4,0x00e0, 0x03b4,0x00fb, 0x03b8,0x000f,
+    0x03b8,0x0013, 0x03b8,0x00ab, 0x03b8,0x00bf, 0x03b8,0x00d0, 0x03bd,0x00da,
+    0x03bd,0x012c, 0x03c8,0x000f, 0x03c8,0x0013, 0x03c8,0x0019, 0x03c8,0x001d,
+    0x03cd,0x0086, 0x03cd,0x00ec, 0x03cd,0x0172, 0x03d2,0x00e0, 0x03d2,0x00ef,
+    0x03d2,0x0112, 0x03d2,0x0139, 0x03d2,0x0168, 0x03d6,0x017b, 0x03d6,0x0181,
+    0x03da,0x0133, 0x03da,0x0148, 0x03e2,0x0023, 0x03e2,0x0027, 0x03e6,0x0027,
+    0x03e6,0x0181, 0x03ee,0x017b, 0x03ee,0x0181, 0x03fe,0x003d, 0x0401,0x012a,
+    0x0401,0x019e, 0x0405,0x01a0, 0x040a,0x000d, 0x040a,0x011f, 0x040a,0x016f,
+    0x040d,0x012a, 0x0412,0x017b, 0x041a,0x0033, 0x041a,0x003d, 0x041a,0x0181,
+    0x0421,0x0086, 0x0421,0x009a, 0x0421,0x00ec, 0x0421,0x0172, 0x042e,0x0205,
+    0x043a,0x0205, 0x043e,0x017b, 0x0442,0x01f5, 0x044c,0x0007, 0x0452,0x0033,
+    0x0452,0x01ce, 0x0452,0x01d0, 0x0452,0x01f1, 0x0452,0x01fb, 0x0452,0x0225,
+    0x0454,0x0005, 0x045a,0x0033, 0x045a,0x0181, 0x045a,0x01ce, 0x045a,0x01d0,
+    0x045a,0x01f1, 0x0469,0x01de, 0x046e,0x0181, 0x047a,0x01ce, 0x047a,0x01f1,
+    0x0485,0x012c, 0x0489,0x012c, 0x0490,0x01d8, 0x0496,0x0033, 0x0496,0x003d,
+    0x0498,0x008f, 0x0498,0x00f3, 0x049e,0x0044, 0x049e,0x0221, 0x04a1,0x0006,
+    0x04a2,0x0044, 0x04a6,0x0221, 0x04a9,0x0004, 0x04ac,0x0027, 0x04b1,0x009a,
+    0x04b6,0x0097, 0x04b8,0x0027, 0x04c6,0x0219, 0x04ca,0x017b, 0x04cc,0x004b,
+    0x04d0,0x00ab, 0x04d6,0x017b, 0x04d8,0x000f, 0x04d8,0x0019, 0x04d8,0x0033,
+    0x04d8,0x003d, 0x04de,0x003d, 0x04de,0x0103, 0x04de,0x018b, 0x04de,0x0231,
+    0x04e2,0x0044, 0x04e2,0x009e, 0x04e2,0x0106, 0x04e2,0x0198, 0x04e5,0x01a4,
+    0x04e5,0x01b6, 0x04ea,0x009e, 0x04ea,0x0106, 0x04ea,0x0198, 0x04ed,0x002e,
+    0x04ed,0x0038, 0x04ed,0x00a2, 0x04f1,0x0086, 0x04f1,0x009a, 0x04f1,0x00ec,
+    0x04f1,0x0172, 0x04f9,0x004e, 0x04f8,0x0229, 0x04f8,0x022d, 0x0500,0x023e,
+    0x0504,0x0217, 0x0510,0x00f3, 0x0514,0x0043, 0x0514,0x004d, 0x0514,0x00c3,
+    0x0514,0x013d, 0x0514,0x0215, 0x0514,0x0232, 0x0515,0x0260, 0x0519,0x002a,
+    0x0518,0x0030, 0x0518,0x0067, 0x0518,0x00c9, 0x0518,0x01eb, 0x0518,0x01ef,
+    0x051c,0x0139, 0x051c,0x0168, 0x0520,0x0027, 0x0526,0x014e, 0x0526,0x0175,
+    0x0526,0x018d, 0x052d,0x0200, 0x0532,0x0021, 0x0532,0x00bf, 0x0532,0x00d0,
+    0x0532,0x0239, 0x0532,0x0266, 0x053d,0x0024, 0x053d,0x00da, 0x054a,0x000f,
+    0x054a,0x00ab, 0x054a,0x023a, 0x054e,0x0043, 0x054e,0x004d, 0x054e,0x00c3,
+    0x054e,0x013d, 0x054e,0x0215, 0x054e,0x0232, 0x054e,0x029d, 0x0552,0x014e,
+    0x0552,0x018d, 0x0556,0x00f3, 0x0556,0x01e4, 0x055a,0x0299, 0x055d,0x0086,
+    0x055d,0x009a, 0x055d,0x00ec, 0x055d,0x0172, 0x0566,0x01dc, 0x0566,0x02a5,
+    0x056d,0x020a, 0x057a,0x003d, 0x057a,0x01d4, 0x057a,0x01f3, 0x0579,0x025e,
+    0x057e,0x0139, 0x057e,0x0168, 0x0581,0x0006, 0x0586,0x017b, 0x0586,0x0181,
+    0x0586,0x028c, 0x0588,0x0007, 0x058e,0x0033, 0x058e,0x008f, 0x058e,0x01d0,
+    0x058e,0x027c, 0x0590,0x0003, 0x0596,0x0033, 0x0596,0x008f, 0x0596,0x0095,
+    0x0596,0x01d0, 0x0596,0x027c, 0x05a2,0x026f, 0x05a5,0x0284, 0x05aa,0x017b,
+    0x05ac,0x0205, 0x05b2,0x008f, 0x05b6,0x017b, 0x05b8,0x01da, 0x05c1,0x0276,
+    0x05c6,0x0248, 0x05c8,0x0247, 0x05c8,0x027e, 0x05cc,0x003d, 0x05cc,0x01d4,
+    0x05cc,0x01f3, 0x05d0,0x014e, 0x05d0,0x018d, 0x05da,0x00f9, 0x05dd,0x0006,
+    0x05de,0x0044, 0x05e5,0x002e, 0x05e6,0x02f1, 0x05ea,0x01d4, 0x05ea,0x01f3,
+    0x05ea,0x022d, 0x05ed,0x0002, 0x05f6,0x0027, 0x05fa,0x0097, 0x05fc,0x003d,
+    0x0602,0x003d, 0x0606,0x00f3, 0x060a,0x0027, 0x060e,0x003d, 0x060e,0x0103,
+    0x060e,0x018b, 0x060e,0x0231, 0x060e,0x02d1, 0x0611,0x01fc, 0x0611,0x0234,
+    0x061a,0x0287, 0x061d,0x0214, 0x0621,0x01d4, 0x062a,0x0027, 0x062a,0x022d,
+    0x062e,0x009e, 0x062e,0x0106, 0x062e,0x0198, 0x0632,0x009e, 0x0632,0x0106,
+    0x0632,0x0198, 0x0639,0x0042, 0x0639,0x00b2, 0x0639,0x0108, 0x063d,0x01f8,
+    0x0641,0x0086, 0x0641,0x009a, 0x0641,0x00ec, 0x0641,0x0172, 0x0645,0x0044,
+    0x0649,0x0042, 0x0648,0x0087, 0x0648,0x00ed, 0x0648,0x0173, 0x0649,0x01a0,
+    0x0648,0x0241, 0x0648,0x026f, 0x0648,0x02df, 0x0648,0x0307, 0x064c,0x023a,
+    0x064c,0x02b3, 0x0651,0x0062, 0x0650,0x0217, 0x0651,0x02ac, 0x0650,0x02d6,
+    0x0655,0x0042, 0x065d,0x0042, 0x0664,0x02b1, 0x0664,0x02ce, 0x0669,0x0238,
+    0x066d,0x002a, 0x066c,0x0039, 0x066d,0x01f6, 0x066c,0x0213, 0x066c,0x022e,
+    0x066d,0x02a2, 0x066c,0x02e1, 0x0671,0x002a, 0x0670,0x0030, 0x0670,0x0067,
+    0x0670,0x00c9, 0x0670,0x01eb, 0x0670,0x01ef, 0x0670,0x02c3, 0x0675,0x0020,
+    0x0678,0x0133, 0x0678,0x0148, 0x067c,0x0027, 0x0681,0x023a, 0x0684,0x0021,
+    0x0684,0x00bf, 0x0684,0x00d0, 0x0689,0x01fc, 0x068e,0x0162, 0x068e,0x0183,
+    0x0691,0x0200, 0x0696,0x0023, 0x0696,0x00e0, 0x0696,0x00fb, 0x0696,0x0268,
+    0x069a,0x0282, 0x069d,0x007e, 0x06a2,0x004b, 0x06a2,0x023e, 0x06a2,0x02dc,
+    0x06a6,0x0097, 0x06aa,0x02b1, 0x06aa,0x02ce, 0x06ae,0x0039, 0x06ae,0x0213,
+    0x06ae,0x022e, 0x06ae,0x02e1, 0x06b2,0x0162, 0x06b2,0x0183, 0x06b6,0x0023,
+    0x06b6,0x00e0, 0x06b6,0x00fb, 0x06ba,0x008f, 0x06ba,0x01e4, 0x06be,0x034b,
+    0x06c1,0x0086, 0x06c1,0x009a, 0x06c1,0x00ec, 0x06c1,0x0172, 0x06c6,0x01da,
+    0x06c6,0x0280, 0x06c6,0x0351, 0x06ce,0x008f, 0x06d2,0x01e3, 0x06d2,0x0287,
+    0x06d2,0x0353, 0x06d6,0x027a, 0x06d6,0x029b, 0x06da,0x0033, 0x06da,0x01ce,
+    0x06da,0x01f1, 0x06de,0x0133, 0x06de,0x0148, 0x06e2,0x0021, 0x06e2,0x00bf,
+    0x06e2,0x00d0, 0x06e5,0x023a, 0x06e9,0x0004, 0x06ee,0x028c, 0x06ee,0x0338,
+    0x06f2,0x0328, 0x06f2,0x0330, 0x06f4,0x0005, 0x06f9,0x01e0, 0x06fe,0x0328,
+    0x06fe,0x0330, 0x0702,0x003d, 0x0702,0x00f3, 0x0702,0x0330, 0x0704,0x0003,
+    0x070a,0x003d, 0x070a,0x00f3, 0x070a,0x01d4, 0x070a,0x01f3, 0x070a,0x0330,
+    0x0711,0x032a, 0x0711,0x032e, 0x0716,0x003d, 0x0718,0x0205, 0x0718,0x0282,
+    0x071e,0x00f3, 0x0720,0x01dc, 0x0720,0x02a5, 0x0726,0x0324, 0x072a,0x028a,
+    0x072a,0x02a7, 0x0729,0x031c, 0x0729,0x032a, 0x072e,0x003d, 0x072e,0x00f9,
+    0x072e,0x022d, 0x072e,0x0248, 0x072e,0x02e4, 0x0730,0x003d, 0x0730,0x0247,
+    0x0730,0x02e3, 0x0730,0x0324, 0x0732,0x0324, 0x0739,0x032e, 0x073e,0x003d,
+    0x0740,0x003d, 0x0744,0x027a, 0x0744,0x029b, 0x0748,0x0033, 0x0748,0x01ce,
+    0x0748,0x01f1, 0x074c,0x0162, 0x074c,0x0183, 0x0750,0x0023, 0x0750,0x00e0,
+    0x0750,0x00fb, 0x0755,0x0246, 0x075a,0x0095, 0x075a,0x0397, 0x075d,0x0004,
+    0x076a,0x03b3, 0x076d,0x0002, 0x0772,0x02fb, 0x0772,0x0301, 0x0772,0x0315,
+    0x0772,0x0397, 0x0776,0x008f, 0x077e,0x0027, 0x078a,0x00a1, 0x0792,0x009d,
+    0x0792,0x00c3, 0x0792,0x02fb, 0x0792,0x0301, 0x0792,0x0315, 0x0792,0x03bd,
+    0x0796,0x0027, 0x0796,0x024f, 0x079e,0x009d, 0x07a6,0x009d, 0x07a6,0x02fb,
+    0x07a6,0x0301, 0x07a6,0x0315, 0x07a6,0x03bd, 0x07aa,0x0027, 0x07aa,0x024f,
+    0x07ae,0x009d, 0x07b9,0x004e, 0x07b8,0x0087, 0x07b8,0x00ed, 0x07b8,0x0173,
+    0x07b8,0x0197, 0x07b9,0x021a, 0x07b9,0x02b8, 0x07b9,0x0364, 0x07be,0x0029,
+    0x07be,0x0030, 0x07c0,0x017b, 0x07c6,0x017b, 0x07c8,0x00f3, 0x07ce,0x00f3,
+    0x07d0,0x008f, 0x07d6,0x008f, 0x07d9,0x01e8, 0x07dd,0x0292, 0x07e2,0x0053,
+    0x07e6,0x008f, 0x07e6,0x00f3, 0x07e6,0x017b, 0x07e8,0x0029, 0x07e8,0x0030,
+    0x07ec,0x0021, 0x07ec,0x02ad, 0x07f2,0x0181, 0x07f2,0x0315, 0x07f4,0x0021,
+    0x07f8,0x020f, 0x07fd,0x002e, 0x0800,0x008f, 0x0805,0x0006, 0x0809,0x03c2,
+    0x080d,0x0084, 0x0812,0x0009, 0x0811,0x0008, 0x0812,0x00f3, 0x0812,0x00f9,
+    0x0812,0x017b, 0x0812,0x0181, 0x0814,0x0033, 0x0818,0x0023, 0x081c,0x0285,
+    0x0826,0x03bd, 0x082c,0x008f, 0x082c,0x017b, 0x0832,0x0043, 0x0832,0x011b,
+    0x0832,0x01b3, 0x0832,0x01c3, 0x0835,0x032a, 0x0838,0x0085, 0x0839,0x032a,
+    0x083e,0x0049, 0x083d,0x0084, 0x083e,0x02fb, 0x083e,0x0301, 0x083e,0x0315,
+    0x083e,0x0397, 0x0842,0x0009, 0x0841,0x0008, 0x0844,0x0009, 0x0846,0x008f,
+    0x084a,0x0033, 0x084e,0x0285, 0x0851,0x009a, 0x0856,0x00a1, 0x0859,0x031c,
+    0x085d,0x00b2, 0x0861,0x0012, 0x0861,0x02cc, 0x0865,0x0058, 0x0865,0x007e,
+    0x0869,0x004a, 0x0871,0x0010, 0x0876,0x003d, 0x0879,0x032c, 0x087e,0x0089,
+    0x0882,0x0229, 0x0882,0x022d, 0x0882,0x02c7, 0x0882,0x02cb, 0x0886,0x0021,
+    0x0886,0x02ad, 0x0885,0x0356, 0x088a,0x0017, 0x088a,0x020f, 0x0889,0x0354,
+    0x088d,0x009c, 0x0892,0x0089, 0x0895,0x0246, 0x089a,0x03bd, 0x089e,0x008f,
+    0x089e,0x02f9, 0x089e,0x0313, 0x08a1,0x032a, 0x08a6,0x0053, 0x08a6,0x0095,
+    0x08a6,0x0397, 0x08a8,0x017b, 0x08ad,0x031a, 0x08b2,0x017b, 0x08b4,0x00f3,
+    0x08b5,0x02a0, 0x08b8,0x0089, 0x08c1,0x0024, 0x08c4,0x00f3, 0x08c9,0x007e,
+    0x08cd,0x007c, 0x08cd,0x0222, 0x08cd,0x0294, 0x08d1,0x003a, 0x08d6,0x0009,
+    0x08d9,0x003a, 0x08dc,0x001f, 0x08e0,0x008f, 0x08e0,0x017b, 0x08e4,0x0009,
+    0x08e8,0x01ed, 0x08ed,0x031c, 0x08f2,0x003d, 0x08f6,0x008f, 0x08f6,0x017b,
+    0x08fa,0x0009, 0x08fe,0x003d, 0x0902,0x01e9, 0x0904,0x01e9, 0x0904,0x0381,
+    0x090a,0x03b1, 0x090d,0x031a, 0x0910,0x0299, 0x0914,0x034b, 0x0919,0x0008,
+    0x091c,0x0033, 0x091c,0x003d, 0x0920,0x0027, 0x0924,0x0027, 0x0924,0x01fb,
+    0x092a,0x01ce, 0x092a,0x01f1, 0x092d,0x031c, 0x0930,0x001f, 0x0936,0x00c5,
+    0x0938,0x00c5, 0x0938,0x0381, 0x093c,0x001b, 0x0942,0x017d, 0x094a,0x0027,
+    0x094e,0x0027, 0x094e,0x01fb, 0x0952,0x03b1, 0x095a,0x0029, 0x095a,0x0030,
+    0x095d,0x0030, 0x0961,0x0030, 0x0966,0x02f9, 0x0966,0x0313, 0x0968,0x02eb,
+    0x096d,0x0008, 0x0970,0x017b, 0x0974,0x0033, 0x0979,0x0150, 0x097d,0x009a,
+    0x0982,0x0293, 0x0984,0x0293, 0x0984,0x0379, 0x098a,0x02eb, 0x098e,0x0009,
+    0x0992,0x003d, 0x0996,0x003d, 0x0999,0x0062, 0x099e,0x003d, 0x09a0,0x0027,
+    0x09a5,0x0144, 0x09a8,0x02b5, 0x09ae,0x008f, 0x09ae,0x009d, 0x09b2,0x004d,
+    0x09b2,0x0053, 0x09b2,0x00c3, 0x09b2,0x013d, 0x09b2,0x01c5, 0x09b2,0x0271,
+    0x09b4,0x0025, 0x09ba,0x0033, 0x09ba,0x0079, 0x09bc,0x0015, 0x09c2,0x013f,
+    0x09c4,0x013f, 0x09c4,0x0379, 0x09ca,0x02b5, 0x09cd,0x0006, 0x09da,0x0009,
+    0x09d9,0x0008, 0x09dc,0x000b, 0x09dc,0x004f, 0x09dd,0x0086, 0x09e0,0x0009,
+    0x09e6,0x00a1, 0x09e8,0x0009, 0x09ed,0x0086, 0x09f2,0x001f, 0x09f2,0x002f,
+    0x09f2,0x0049, 0x09f2,0x006f, 0x09f2,0x0085, 0x09f2,0x0091, 0x09f2,0x00a9,
+    0x09f2,0x00d3, 0x09f2,0x00d7, 0x09f2,0x011d, 0x09f2,0x0121, 0x09f2,0x0235,
+    0x09f2,0x0393, 0x09f6,0x0324, 0x09f8,0x0049, 0x09f8,0x00a9, 0x09f8,0x011d,
+    0x09fe,0x001f, 0x09fe,0x0029, 0x09fe,0x0033, 0x09fe,0x003d, 0x09fe,0x0085,
+    0x09fe,0x008f, 0x09fe,0x00d3, 0x0a00,0x003d, 0x0a06,0x012d, 0x0a0e,0x00b3,
+    0x0a10,0x000b, 0x0a10,0x0387, 0x0a16,0x0059, 0x0a18,0x0009, 0x0a1e,0x0043,
+    0x0a24,0x0085, 0x0a2a,0x0009, 0x0a2d,0x0008, 0x0a32,0x028a, 0x0a32,0x02a7,
+    0x0a31,0x031c, 0x0a35,0x032e, 0x0a39,0x0006, 0x0a3a,0x0105, 0x0a3a,0x024f,
+    0x0a3c,0x0299, 0x0a42,0x01ed, 0x0a46,0x0299, 0x0a48,0x01ed, 0x0a4c,0x0059,
+    0x0a52,0x000b, 0x0a52,0x0387, 0x0a56,0x000b, 0x0a5e,0x0009, 0x0a60,0x003d,
+    0x0a66,0x0105, 0x0a6a,0x0195, 0x0a6c,0x000b, 0x0a76,0x0053, 0x0a78,0x0009,
+    0x0a7a,0x008f, 0x0a82,0x0299, 0x0a86,0x01ed, 0x0a8a,0x0027, 0x0a8e,0x004b,
+    0x0a92,0x003d, 0x0a95,0x0322, 0x0a99,0x0038, 0x0a99,0x0090, 0x0a9c,0x0061,
+    0x0a9c,0x00c7, 0x0a9c,0x012d, 0x0a9c,0x016f, 0x0a9c,0x017d, 0x0a9c,0x02c9,
+    0x0a9c,0x0383, 0x0aa1,0x0010, 0x0aa4,0x00b3, 0x0aa8,0x002f, 0x0aac,0x0027,
+    0x0ab0,0x004b, 0x0ab4,0x0043, 0x0ab9,0x0090, 0x0abd,0x0010, 0x0ac4,0x0019,
+    0x0acc,0x00f5, 0x0acc,0x022b, 0x0acc,0x037b, 0x0ad2,0x008f, 0x0ad2,0x01f1,
+    0x0ad6,0x0324, 0x0ad9,0x0330, 0x0ade,0x008f, 0x0ade,0x01f1, 0x0ae0,0x017b,
+    0x0ae4,0x008f, 0x0ae9,0x004e, 0x0aee,0x0027, 0x0af2,0x028a, 0x0af2,0x02a7,
+    0x0af1,0x031c, 0x0af6,0x0027, 0x0af9,0x031c, 0x0afe,0x00e9, 0x0afe,0x02bb,
+    0x0b02,0x000b, 0x0b06,0x00f5, 0x0b06,0x022b, 0x0b06,0x037b, 0x0b0a,0x003d,
+    0x0000,0x0000
+};
 
 ////////////////////////////////////////////////////////////////////////
 ///                     FUNCTION DEFINITIONS                         ///
@@ -62,20 +437,21 @@ void Rwr_ManWriteToArray( Rwr_Man_t * p )
     {
         if ( i % 5 == 0 )
             fprintf( pFile, "\n    " );
-        pNode = p->vForest->pArray[i+5];
+        pNode = (Rwr_Node_t *)p->vForest->pArray[i+5];
         Entry0 = (Rwr_Regular(pNode->p0)->Id << 1) | Rwr_IsComplement(pNode->p0);
         Entry1 = (Rwr_Regular(pNode->p1)->Id << 1) | Rwr_IsComplement(pNode->p1);
         Entry0 = (Entry0 << 1) | pNode->fExor;
-        Extra_PrintHex( pFile, Entry0, 4 );
+        Extra_PrintHex( pFile, &Entry0, 4 );
         fprintf( pFile, "," );
-        Extra_PrintHex( pFile, Entry1, 4 );
+        Extra_PrintHex( pFile, &Entry1, 4 );
         fprintf( pFile, ", " );
     }
     if ( i % 5 == 0 )
         fprintf( pFile, "\n    " );
-    Extra_PrintHex( pFile, 0, 4 );
+    Entry0 = 0;
+    Extra_PrintHex( pFile, &Entry0, 4 );
     fprintf( pFile, "," );
-    Extra_PrintHex( pFile, 0, 4 );
+    Extra_PrintHex( pFile, &Entry0, 4 );
     fprintf( pFile, " \n};\n" );
     fclose( pFile );
     printf( "The number of nodes saved = %d.   ", nEntries );  ABC_PRT( "Saving", clock() - clk );
@@ -111,8 +487,8 @@ void Rwr_ManLoadFromArray( Rwr_Man_t * p, int fVerbose )
         fExor = (Entry0 & 1);
         Entry0 >>= 1;
         // get the nodes
-        p0 = p->vForest->pArray[Entry0 >> 1];
-        p1 = p->vForest->pArray[Entry1 >> 1];
+        p0 = (Rwr_Node_t *)p->vForest->pArray[Entry0 >> 1];
+        p1 = (Rwr_Node_t *)p->vForest->pArray[Entry1 >> 1];
         // compute the level and volume of the new nodes
         Level  = 1 + ABC_MAX( p0->Level, p1->Level );
         Volume = 1 + Rwr_ManNodeVolume( p, p0, p1 );
@@ -154,7 +530,7 @@ void Rwr_ManWriteToFile( Rwr_Man_t * p, char * pFileName )
     pBuffer = ABC_ALLOC( unsigned, nEntries * 2 );
     for ( i = 0; i < nEntries; i++ )
     {
-        pNode = p->vForest->pArray[i+5];
+        pNode = (Rwr_Node_t *)p->vForest->pArray[i+5];
         pBuffer[2*i + 0] = (Rwr_Regular(pNode->p0)->Id << 1) | Rwr_IsComplement(pNode->p0);
         pBuffer[2*i + 1] = (Rwr_Regular(pNode->p1)->Id << 1) | Rwr_IsComplement(pNode->p1);
         // save EXOR flag
@@ -206,8 +582,8 @@ void Rwr_ManLoadFromFile( Rwr_Man_t * p, char * pFileName )
         fExor = (pBuffer[2*i + 0] & 1);
         pBuffer[2*i + 0] = (pBuffer[2*i + 0] >> 1);
         // get the nodes
-        p0 = p->vForest->pArray[pBuffer[2*i + 0] >> 1];
-        p1 = p->vForest->pArray[pBuffer[2*i + 1] >> 1];
+        p0 = (Rwr_Node_t *)p->vForest->pArray[pBuffer[2*i + 0] >> 1];
+        p1 = (Rwr_Node_t *)p->vForest->pArray[pBuffer[2*i + 1] >> 1];
         // compute the level and volume of the new nodes
         Level  = 1 + ABC_MAX( p0->Level, p1->Level );
         Volume = 1 + Rwr_ManNodeVolume( p, p0, p1 );
@@ -276,384 +652,5 @@ char * Rwr_ManGetPractical( Rwr_Man_t * p )
 ///                       END OF FILE                                ///
 ////////////////////////////////////////////////////////////////////////
 
-// the following 135 practical NPN classes of 4-variable functions were computed
-// by considering all 4-input cuts appearing in IWLS, MCNC, and ISCAS benchmarks
-static unsigned short s_RwrPracticalClasses[] = 
-{
-    0x0000, 0x0001, 0x0003, 0x0006, 0x0007, 0x000f, 0x0016, 0x0017, 0x0018, 0x0019, 0x001b, 
-    0x001e, 0x001f, 0x003c, 0x003d, 0x003f, 0x0069, 0x006b, 0x006f, 0x007e, 0x007f, 0x00ff, 
-    0x0116, 0x0118, 0x0119, 0x011a, 0x011b, 0x011e, 0x011f, 0x012c, 0x012d, 0x012f, 0x013c, 
-    0x013d, 0x013e, 0x013f, 0x0168, 0x0169, 0x016f, 0x017f, 0x0180, 0x0181, 0x0182, 0x0183, 
-    0x0186, 0x0189, 0x018b, 0x018f, 0x0198, 0x0199, 0x019b, 0x01a8, 0x01a9, 0x01aa, 0x01ab, 
-    0x01ac, 0x01ad, 0x01ae, 0x01af, 0x01bf, 0x01e9, 0x01ea, 0x01eb, 0x01ee, 0x01ef, 0x01fe, 
-    0x033c, 0x033d, 0x033f, 0x0356, 0x0357, 0x0358, 0x0359, 0x035a, 0x035b, 0x035f, 0x0368, 
-    0x0369, 0x036c, 0x036e, 0x037d, 0x03c0, 0x03c1, 0x03c3, 0x03c7, 0x03cf, 0x03d4, 0x03d5, 
-    0x03d7, 0x03d8, 0x03d9, 0x03dc, 0x03dd, 0x03de, 0x03fc, 0x0660, 0x0661, 0x0666, 0x0669, 
-    0x066f, 0x0676, 0x067e, 0x0690, 0x0696, 0x0697, 0x069f, 0x06b1, 0x06b6, 0x06f0, 0x06f2, 
-    0x06f6, 0x06f9, 0x0776, 0x0778, 0x07b0, 0x07b1, 0x07b4, 0x07bc, 0x07f0, 0x07f2, 0x07f8, 
-    0x0ff0, 0x1683, 0x1696, 0x1698, 0x169e, 0x16e9, 0x178e, 0x17e8, 0x18e7, 0x19e6, 0x1be4, 
-    0x1ee1, 0x3cc3, 0x6996, 0x0000
-};
-
-static unsigned short s_RwtAigSubgraphs[] = 
-{
-    0x0008,0x0002, 0x000a,0x0002, 0x0008,0x0003, 0x000a,0x0003, 0x0009,0x0002, 
-    0x000c,0x0002, 0x000e,0x0002, 0x000c,0x0003, 0x000e,0x0003, 0x000d,0x0002, 
-    0x000c,0x0004, 0x000e,0x0004, 0x000c,0x0005, 0x000e,0x0005, 0x000d,0x0004, 
-    0x0010,0x0002, 0x0012,0x0002, 0x0010,0x0003, 0x0012,0x0003, 0x0011,0x0002, 
-    0x0010,0x0004, 0x0012,0x0004, 0x0010,0x0005, 0x0012,0x0005, 0x0011,0x0004, 
-    0x0010,0x0006, 0x0012,0x0006, 0x0010,0x0007, 0x0012,0x0007, 0x0011,0x0006, 
-    0x0016,0x0005, 0x0014,0x0006, 0x0016,0x0006, 0x0014,0x0007, 0x0016,0x0007, 
-    0x0015,0x0006, 0x0014,0x0008, 0x0016,0x0008, 0x0014,0x0009, 0x0016,0x0009, 
-    0x0015,0x0008, 0x0018,0x0006, 0x001a,0x0006, 0x0018,0x0007, 0x001a,0x0007, 
-    0x0019,0x0006, 0x0018,0x0009, 0x001a,0x0009, 0x0019,0x0008, 0x001e,0x0005, 
-    0x001c,0x0006, 0x001e,0x0006, 0x001c,0x0007, 0x001e,0x0007, 0x001d,0x0006, 
-    0x001c,0x0008, 0x001e,0x0008, 0x001c,0x0009, 0x001e,0x0009, 0x001d,0x0008, 
-    0x0020,0x0006, 0x0022,0x0006, 0x0020,0x0007, 0x0022,0x0007, 0x0021,0x0006, 
-    0x0020,0x0008, 0x0022,0x0008, 0x0020,0x0009, 0x0022,0x0009, 0x0021,0x0008, 
-    0x0024,0x0006, 0x0026,0x0006, 0x0024,0x0007, 0x0026,0x0007, 0x0025,0x0006, 
-    0x0026,0x0008, 0x0024,0x0009, 0x0026,0x0009, 0x0025,0x0008, 0x0028,0x0004, 
-    0x002a,0x0004, 0x0028,0x0005, 0x002a,0x0007, 0x0028,0x0008, 0x002a,0x0009, 
-    0x0029,0x0008, 0x002a,0x000b, 0x0029,0x000a, 0x002a,0x000f, 0x0029,0x000e, 
-    0x002a,0x0011, 0x002a,0x0013, 0x002c,0x0004, 0x002e,0x0004, 0x002c,0x0005, 
-    0x002c,0x0009, 0x002e,0x0009, 0x002d,0x0008, 0x002d,0x000c, 0x002e,0x000f, 
-    0x002e,0x0011, 0x002e,0x0012, 0x0030,0x0004, 0x0032,0x0007, 0x0032,0x0009, 
-    0x0031,0x0008, 0x0032,0x000b, 0x0032,0x000d, 0x0032,0x000f, 0x0031,0x000e, 
-    0x0032,0x0013, 0x0034,0x0004, 0x0036,0x0004, 0x0034,0x0005, 0x0036,0x0005, 
-    0x0035,0x0004, 0x0036,0x0008, 0x0034,0x0009, 0x0036,0x0009, 0x0035,0x0008, 
-    0x0036,0x000b, 0x0036,0x000d, 0x0036,0x0011, 0x0035,0x0010, 0x0036,0x0013, 
-    0x0038,0x0004, 0x0039,0x0004, 0x0038,0x0009, 0x003a,0x0009, 0x0039,0x0008, 
-    0x0038,0x000b, 0x003a,0x000b, 0x003a,0x000d, 0x003a,0x0011, 0x003a,0x0012, 
-    0x0038,0x0013, 0x003a,0x0013, 0x003c,0x0002, 0x003e,0x0002, 0x003c,0x0003, 
-    0x003e,0x0005, 0x003e,0x0007, 0x003c,0x0008, 0x003e,0x0008, 0x003c,0x0009, 
-    0x003e,0x0009, 0x003d,0x0008, 0x003e,0x000d, 0x003e,0x0011, 0x003e,0x0013, 
-    0x003e,0x0017, 0x003e,0x001b, 0x003e,0x001d, 0x0040,0x0002, 0x0042,0x0002, 
-    0x0042,0x0005, 0x0041,0x0006, 0x0042,0x0008, 0x0041,0x0008, 0x0042,0x000d, 
-    0x0042,0x0011, 0x0042,0x0015, 0x0042,0x0019, 0x0042,0x001b, 0x0042,0x001c, 
-    0x0041,0x001c, 0x0044,0x0002, 0x0046,0x0003, 0x0045,0x0004, 0x0046,0x0007, 
-    0x0045,0x0008, 0x0046,0x000b, 0x0046,0x000f, 0x0046,0x0013, 0x0045,0x0012, 
-    0x0046,0x0017, 0x0046,0x001b, 0x0046,0x0021, 0x0048,0x0002, 0x004a,0x0002, 
-    0x0048,0x0003, 0x004a,0x0003, 0x0049,0x0002, 0x0048,0x0008, 0x004a,0x0008, 
-    0x0048,0x0009, 0x004a,0x0009, 0x0049,0x0008, 0x004a,0x000b, 0x004a,0x000f, 
-    0x004a,0x0011, 0x004a,0x0012, 0x004a,0x0013, 0x004a,0x0015, 0x004a,0x0019, 
-    0x004a,0x001b, 0x004a,0x001d, 0x004c,0x0002, 0x004c,0x0003, 0x004d,0x0002, 
-    0x004c,0x0008, 0x004e,0x0008, 0x004c,0x0009, 0x004e,0x0009, 0x004d,0x0008, 
-    0x004c,0x000b, 0x004e,0x000b, 0x004c,0x000f, 0x004e,0x000f, 0x004e,0x0011, 
-    0x004c,0x0012, 0x004c,0x0013, 0x004e,0x0013, 0x004e,0x0015, 0x004c,0x0017, 
-    0x004e,0x0019, 0x004c,0x001b, 0x004e,0x001b, 0x004c,0x001c, 0x004c,0x001d, 
-    0x004e,0x001d, 0x0050,0x0004, 0x0052,0x0004, 0x0050,0x0006, 0x0052,0x0009, 
-    0x0052,0x000d, 0x0052,0x000f, 0x0052,0x0013, 0x0052,0x0017, 0x0052,0x0019, 
-    0x0052,0x001d, 0x0052,0x001f, 0x0052,0x0021, 0x0052,0x0023, 0x0052,0x0024, 
-    0x0052,0x0025, 0x0051,0x0024, 0x0052,0x0027, 0x0054,0x0004, 0x0056,0x0004, 
-    0x0054,0x0005, 0x0056,0x0006, 0x0054,0x0007, 0x0056,0x0011, 0x0056,0x001b, 
-    0x0056,0x001e, 0x0054,0x001f, 0x0056,0x001f, 0x0056,0x0020, 0x0054,0x0021, 
-    0x0055,0x0020, 0x0056,0x0024, 0x0054,0x0025, 0x0056,0x0025, 0x0055,0x0024, 
-    0x0054,0x0027, 0x0056,0x0027, 0x0055,0x0026, 0x005a,0x0007, 0x005a,0x0009, 
-    0x005a,0x000b, 0x005a,0x0015, 0x005a,0x001f, 0x0059,0x0020, 0x0058,0x0024, 
-    0x005a,0x0024, 0x005a,0x0027, 0x0059,0x0026, 0x005c,0x0004, 0x005e,0x0004, 
-    0x005c,0x0005, 0x005e,0x0006, 0x005c,0x0007, 0x005d,0x0006, 0x005e,0x000d, 
-    0x005e,0x0013, 0x005e,0x0017, 0x005c,0x001f, 0x005d,0x001e, 0x005e,0x0020, 
-    0x005e,0x0021, 0x005e,0x0022, 0x005e,0x0023, 0x005c,0x0024, 0x005e,0x0024, 
-    0x005c,0x0025, 0x005e,0x0025, 0x005d,0x0024, 0x005e,0x0026, 0x005e,0x0027, 
-    0x0062,0x0004, 0x0061,0x0004, 0x0062,0x0006, 0x0061,0x0006, 0x0060,0x000f, 
-    0x0060,0x0013, 0x0062,0x0013, 0x0060,0x0019, 0x0062,0x001c, 0x0060,0x001d, 
-    0x0062,0x001d, 0x0062,0x001f, 0x0060,0x0021, 0x0060,0x0023, 0x0062,0x0024, 
-    0x0060,0x0027, 0x0061,0x0026, 0x0064,0x0002, 0x0066,0x0002, 0x0064,0x0006, 
-    0x0066,0x0007, 0x0066,0x0009, 0x0066,0x000d, 0x0066,0x0013, 0x0066,0x0015, 
-    0x0066,0x0017, 0x0066,0x0019, 0x0066,0x001a, 0x0065,0x001a, 0x0066,0x001f, 
-    0x0066,0x0023, 0x0066,0x0027, 0x0066,0x002f, 0x0066,0x0030, 0x006a,0x0002, 
-    0x0068,0x0003, 0x0068,0x0006, 0x006a,0x0006, 0x006a,0x0011, 0x0068,0x0016, 
-    0x0068,0x0017, 0x006a,0x0017, 0x006a,0x001a, 0x006a,0x001b, 0x006a,0x0025, 
-    0x006a,0x002d, 0x006e,0x0003, 0x006e,0x0007, 0x006e,0x0009, 0x006e,0x000b, 
-    0x006e,0x0015, 0x006e,0x0016, 0x006e,0x0017, 0x006c,0x001a, 0x006e,0x001a, 
-    0x006e,0x001f, 0x006e,0x002b, 0x006e,0x0035, 0x0070,0x0002, 0x0070,0x0003, 
-    0x0072,0x0006, 0x0070,0x0007, 0x0071,0x0006, 0x0072,0x000b, 0x0072,0x000f, 
-    0x0072,0x0013, 0x0070,0x0015, 0x0071,0x0014, 0x0072,0x0017, 0x0072,0x0018, 
-    0x0070,0x0019, 0x0072,0x0019, 0x0070,0x001a, 0x0070,0x001b, 0x0072,0x001b, 
-    0x0071,0x001a, 0x0072,0x0021, 0x0072,0x0029, 0x0076,0x0002, 0x0076,0x0003, 
-    0x0075,0x0002, 0x0076,0x0006, 0x0074,0x0007, 0x0076,0x0007, 0x0075,0x0006, 
-    0x0076,0x000d, 0x0076,0x0011, 0x0076,0x0013, 0x0075,0x0014, 0x0076,0x0019, 
-    0x0076,0x001a, 0x0076,0x001b, 0x0075,0x001c, 0x0074,0x0023, 0x0075,0x0022, 
-    0x0074,0x0026, 0x0076,0x0026, 0x0074,0x0027, 0x0076,0x002b, 0x0076,0x002f, 
-    0x0078,0x0002, 0x0078,0x0004, 0x007a,0x0004, 0x007a,0x0005, 0x0079,0x0004, 
-    0x007a,0x0009, 0x007a,0x000a, 0x007a,0x000b, 0x007a,0x000d, 0x007a,0x000f, 
-    0x007a,0x0010, 0x007a,0x0011, 0x007a,0x0012, 0x007a,0x0013, 0x007a,0x0017, 
-    0x007a,0x001b, 0x007a,0x0021, 0x007a,0x0027, 0x007a,0x002b, 0x007a,0x002f, 
-    0x007a,0x0030, 0x0079,0x0034, 0x007a,0x0039, 0x007a,0x003a, 0x007e,0x0002, 
-    0x007c,0x0004, 0x007e,0x0004, 0x007e,0x000c, 0x007c,0x000d, 0x007e,0x0011, 
-    0x007e,0x0013, 0x007e,0x001b, 0x007e,0x0025, 0x007e,0x002d, 0x007e,0x0037, 
-    0x0082,0x0003, 0x0082,0x0005, 0x0082,0x0009, 0x0082,0x000b, 0x0080,0x0010, 
-    0x0082,0x0010, 0x0082,0x0012, 0x0082,0x0015, 0x0082,0x001f, 0x0082,0x002b, 
-    0x0082,0x0035, 0x0082,0x0039, 0x0082,0x003f, 0x0084,0x0002, 0x0086,0x0002, 
-    0x0084,0x0003, 0x0086,0x0003, 0x0085,0x0002, 0x0086,0x0004, 0x0084,0x0005, 
-    0x0085,0x0004, 0x0086,0x000a, 0x0084,0x000b, 0x0085,0x000a, 0x0086,0x000d, 
-    0x0086,0x000e, 0x0086,0x000f, 0x0084,0x0010, 0x0084,0x0011, 0x0086,0x0011, 
-    0x0085,0x0010, 0x0084,0x0012, 0x0084,0x0013, 0x0086,0x0013, 0x0085,0x0012, 
-    0x0086,0x0019, 0x0086,0x0023, 0x0086,0x0029, 0x0086,0x0033, 0x0086,0x0039, 
-    0x008a,0x0003, 0x0089,0x0002, 0x0088,0x0004, 0x008a,0x0004, 0x0088,0x0005, 
-    0x0089,0x0004, 0x008a,0x000b, 0x008a,0x0010, 0x0088,0x0011, 0x008a,0x0011, 
-    0x0089,0x0010, 0x0088,0x0012, 0x008a,0x0012, 0x0089,0x0012, 0x008a,0x0017, 
-    0x008a,0x001b, 0x0089,0x0020, 0x008a,0x0025, 0x0088,0x0027, 0x008a,0x002b, 
-    0x008a,0x002f, 0x008a,0x0039, 0x0088,0x003a, 0x008d,0x0044, 0x0092,0x0009, 
-    0x0092,0x0025, 0x0092,0x0029, 0x0092,0x002d, 0x0092,0x0033, 0x0092,0x0037, 
-    0x0092,0x003d, 0x0092,0x0041, 0x0095,0x0002, 0x0095,0x0004, 0x0095,0x0010, 
-    0x0095,0x0012, 0x0096,0x0021, 0x0096,0x0029, 0x0095,0x002e, 0x0096,0x0030, 
-    0x0096,0x0033, 0x0096,0x003a, 0x0096,0x0043, 0x009a,0x0008, 0x009a,0x0009, 
-    0x0099,0x0008, 0x009a,0x0011, 0x009a,0x0023, 0x009a,0x0033, 0x009a,0x003d, 
-    0x009a,0x0044, 0x009a,0x0045, 0x0099,0x0044, 0x009d,0x0002, 0x009e,0x0008, 
-    0x009c,0x0009, 0x009e,0x0009, 0x009d,0x0008, 0x009e,0x0011, 0x009d,0x0010, 
-    0x009e,0x001f, 0x009e,0x003f, 0x00a0,0x0009, 0x00a0,0x0011, 0x00a2,0x0030, 
-    0x00a2,0x0033, 0x00a6,0x0006, 0x00a6,0x0007, 0x00a6,0x0011, 0x00a6,0x0044, 
-    0x00a6,0x004b, 0x00aa,0x0007, 0x00aa,0x0015, 0x00ae,0x0006, 0x00ae,0x0011, 
-    0x00ae,0x001b, 0x00ae,0x0025, 0x00ae,0x003d, 0x00ae,0x0041, 0x00ae,0x0043, 
-    0x00ae,0x0045, 0x00b2,0x0006, 0x00b0,0x0007, 0x00b1,0x0006, 0x00b2,0x0017, 
-    0x00b1,0x0016, 0x00b0,0x0019, 0x00b2,0x0021, 0x00b2,0x003d, 0x00b5,0x004a, 
-    0x00ba,0x0009, 0x00ba,0x000f, 0x00bc,0x0009, 0x00be,0x0009, 0x00be,0x000f, 
-    0x00bd,0x000e, 0x00be,0x0017, 0x00c2,0x0009, 0x00c2,0x0019, 0x00c2,0x001f, 
-    0x00c2,0x0033, 0x00c6,0x0009, 0x00c5,0x000e, 0x00c6,0x0015, 0x00c6,0x0023, 
-    0x00c4,0x002d, 0x00c6,0x002f, 0x00c5,0x002e, 0x00c6,0x0045, 0x00ce,0x0007, 
-    0x00ce,0x0021, 0x00ce,0x0023, 0x00ce,0x0025, 0x00ce,0x0027, 0x00ce,0x0033, 
-    0x00ce,0x003d, 0x00d2,0x0006, 0x00d0,0x0015, 0x00d0,0x001b, 0x00d2,0x001b, 
-    0x00d1,0x001a, 0x00d0,0x001f, 0x00d2,0x0025, 0x00d1,0x0024, 0x00d2,0x0037, 
-    0x00d2,0x0041, 0x00d2,0x0045, 0x00d9,0x0044, 0x00e1,0x0004, 0x00e2,0x000d, 
-    0x00e2,0x0021, 0x00e0,0x003a, 0x00e6,0x003d, 0x00e6,0x0061, 0x00e6,0x0067, 
-    0x00e9,0x0004, 0x00ea,0x0008, 0x00ea,0x0009, 0x00ea,0x0039, 0x00e9,0x0038, 
-    0x00ea,0x003f, 0x00ec,0x000d, 0x00ee,0x000d, 0x00ee,0x0037, 0x00f2,0x003d, 
-    0x00f2,0x0062, 0x00f5,0x0002, 0x00fa,0x0017, 0x00fa,0x003d, 0x00fe,0x0006, 
-    0x00fd,0x0006, 0x00fc,0x0015, 0x00fe,0x001b, 0x00fc,0x0025, 0x00fe,0x0025, 
-    0x00fd,0x0024, 0x00fe,0x0041, 0x00fe,0x004d, 0x00fd,0x004e, 0x0101,0x0014, 
-    0x0106,0x004d, 0x010a,0x0009, 0x010a,0x000b, 0x0109,0x000a, 0x010a,0x004f, 
-    0x010a,0x0058, 0x010e,0x0008, 0x010c,0x0009, 0x010e,0x0009, 0x010d,0x0008, 
-    0x010e,0x000b, 0x010e,0x002b, 0x010d,0x002a, 0x010e,0x0035, 0x010e,0x003d, 
-    0x010e,0x003f, 0x010e,0x0049, 0x010e,0x0057, 0x010d,0x0056, 0x010d,0x0058, 
-    0x0111,0x0004, 0x0111,0x0006, 0x0110,0x0009, 0x0112,0x0009, 0x0111,0x0008, 
-    0x0112,0x002f, 0x0110,0x0035, 0x0110,0x0037, 0x0112,0x0039, 0x0112,0x003d, 
-    0x0112,0x003f, 0x0112,0x0045, 0x0111,0x0044, 0x0112,0x004b, 0x0112,0x0059, 
-    0x0112,0x0069, 0x0112,0x007f, 0x0116,0x0009, 0x0115,0x0008, 0x0114,0x000b, 
-    0x0116,0x000b, 0x0116,0x0058, 0x011a,0x0015, 0x011a,0x001f, 0x011a,0x002b, 
-    0x011a,0x003f, 0x011a,0x0049, 0x011a,0x0085, 0x011e,0x0007, 0x011e,0x0019, 
-    0x011e,0x001b, 0x011e,0x0023, 0x011e,0x0027, 0x011e,0x002f, 0x011e,0x0043, 
-    0x011e,0x004b, 0x011e,0x004e, 0x011e,0x004f, 0x011e,0x005f, 0x011e,0x0061, 
-    0x011e,0x0065, 0x011e,0x0083, 0x0122,0x0006, 0x0120,0x0007, 0x0122,0x0007, 
-    0x0121,0x0006, 0x0122,0x0049, 0x0121,0x004e, 0x0122,0x008f, 0x0125,0x0004, 
-    0x0124,0x0007, 0x0125,0x0006, 0x0124,0x001b, 0x0126,0x001b, 0x0126,0x0045, 
-    0x0126,0x0087, 0x0128,0x0007, 0x0129,0x0006, 0x012a,0x0019, 0x012a,0x003d, 
-    0x012a,0x0051, 0x012a,0x0065, 0x012a,0x0083, 0x012d,0x005a, 0x0132,0x0009, 
-    0x0132,0x008f, 0x0134,0x0009, 0x0135,0x003e, 0x013a,0x003d, 0x013a,0x0044, 
-    0x0139,0x0044, 0x013e,0x0009, 0x013d,0x0008, 0x013c,0x003d, 0x013c,0x0044, 
-    0x013c,0x0053, 0x013e,0x008f, 0x013e,0x0095, 0x0142,0x0044, 0x0142,0x0097, 
-    0x0142,0x009e, 0x0144,0x0007, 0x0148,0x0015, 0x0148,0x001c, 0x0148,0x001f, 
-    0x0148,0x0026, 0x0149,0x0086, 0x014d,0x0006, 0x014e,0x0044, 0x014d,0x0048, 
-    0x014e,0x009e, 0x0152,0x0009, 0x0151,0x00a6, 0x0155,0x0030, 0x015d,0x003a, 
-    0x0162,0x009e, 0x0164,0x000f, 0x0164,0x0013, 0x0169,0x000e, 0x0174,0x0009, 
-    0x0179,0x0008, 0x0180,0x0009, 0x0181,0x0044, 0x0186,0x0044, 0x0185,0x0044, 
-    0x018a,0x0068, 0x0195,0x004e, 0x01a6,0x0009, 0x01a5,0x0008, 0x01b1,0x003a, 
-    0x01c4,0x0029, 0x01c4,0x0030, 0x01ca,0x008f, 0x01ca,0x0095, 0x01cc,0x0029, 
-    0x01cc,0x0033, 0x01ce,0x003d, 0x01d6,0x00b2, 0x01d8,0x0009, 0x01d9,0x002a, 
-    0x01d9,0x0056, 0x01d9,0x00a4, 0x01dd,0x003a, 0x01e2,0x00b2, 0x01e6,0x0013, 
-    0x01e6,0x009f, 0x01e6,0x00ba, 0x01e6,0x00c0, 0x01e6,0x00d3, 0x01e6,0x00d5, 
-    0x01e6,0x00e5, 0x01e8,0x0005, 0x01f2,0x0013, 0x01f2,0x0095, 0x01f2,0x009f, 
-    0x01f2,0x00ba, 0x01f2,0x00c0, 0x01f2,0x00d3, 0x0202,0x008f, 0x0202,0x0095, 
-    0x0202,0x00f3, 0x0202,0x00f9, 0x020a,0x0044, 0x0209,0x00b4, 0x020e,0x0009, 
-    0x020d,0x0008, 0x020c,0x003d, 0x020c,0x0044, 0x020c,0x0053, 0x020e,0x008f, 
-    0x020e,0x0095, 0x020c,0x00b1, 0x020e,0x00f3, 0x020e,0x00f9, 0x0210,0x0013, 
-    0x0211,0x0024, 0x0210,0x0026, 0x0219,0x0004, 0x021e,0x008f, 0x021e,0x0095, 
-    0x0221,0x003a, 0x0230,0x0009, 0x0236,0x0009, 0x0234,0x0029, 0x0234,0x0030, 
-    0x0234,0x0033, 0x0234,0x003a, 0x0234,0x003d, 0x0234,0x0044, 0x0235,0x00a6, 
-    0x023a,0x0009, 0x023d,0x003a, 0x0245,0x0044, 0x0249,0x003a, 0x024e,0x009e, 
-    0x024e,0x0106, 0x0251,0x0026, 0x0258,0x0013, 0x0259,0x0024, 0x0258,0x0061, 
-    0x0259,0x0086, 0x0258,0x00c7, 0x0258,0x00df, 0x0259,0x00ec, 0x0258,0x00fc, 
-    0x025d,0x0024, 0x025d,0x00de, 0x0260,0x00f6, 0x0268,0x0009, 0x0269,0x0044, 
-    0x0268,0x00f3, 0x0268,0x00f9, 0x026d,0x003a, 0x0270,0x0068, 0x0275,0x003a, 
-    0x027a,0x0044, 0x0279,0x0044, 0x027e,0x007e, 0x0281,0x0044, 0x0285,0x0008, 
-    0x028d,0x0006, 0x028d,0x00d2, 0x0295,0x00cc, 0x0296,0x00f6, 0x0295,0x00f8, 
-    0x0299,0x0030, 0x029e,0x007e, 0x029d,0x0080, 0x02a6,0x008f, 0x02a6,0x0095, 
-    0x02aa,0x0029, 0x02aa,0x0030, 0x02b5,0x0008, 0x02b9,0x003a, 0x02bd,0x0004, 
-    0x02bd,0x00fc, 0x02c2,0x00b2, 0x02c1,0x00b4, 0x02c4,0x0029, 0x02c8,0x0029, 
-    0x02c8,0x0033, 0x02ca,0x003d, 0x02ce,0x0029, 0x02ce,0x0030, 0x02d2,0x0068, 
-    0x02d1,0x006a, 0x02d5,0x006a, 0x02d9,0x0008, 0x02de,0x012c, 0x02e2,0x012c, 
-    0x02e4,0x0009, 0x02e5,0x002a, 0x02e5,0x0056, 0x02e5,0x012c, 0x02ea,0x0029, 
-    0x02ea,0x0030, 0x02e9,0x0030, 0x02ec,0x0029, 0x02ec,0x0030, 0x02ee,0x012c, 
-    0x02f1,0x0068, 0x02f1,0x00b2, 0x02f1,0x0108, 0x02f1,0x012c, 0x02f6,0x0013, 
-    0x02f6,0x0015, 0x02f6,0x001f, 0x02f6,0x0030, 0x02f6,0x0065, 0x02f6,0x0067, 
-    0x02f6,0x009f, 0x02f6,0x00b6, 0x02f6,0x00b9, 0x02f6,0x00c0, 0x02f6,0x00cf, 
-    0x02f6,0x0107, 0x02f6,0x010b, 0x02f6,0x010f, 0x02f6,0x0115, 0x02f6,0x012d, 
-    0x02f6,0x0134, 0x02f6,0x0153, 0x02f6,0x0171, 0x02f6,0x0176, 0x02f8,0x0003, 
-    0x02fa,0x017b, 0x02fc,0x00ba, 0x02fc,0x00d3, 0x0302,0x0013, 0x0302,0x001f, 
-    0x0302,0x0030, 0x0302,0x005d, 0x0302,0x0065, 0x0302,0x0067, 0x0302,0x0099, 
-    0x0302,0x009f, 0x0302,0x00ad, 0x0302,0x00b9, 0x0302,0x00c0, 0x0302,0x00cf, 
-    0x0301,0x00d2, 0x0301,0x00fe, 0x0302,0x0107, 0x0302,0x010b, 0x0302,0x010f, 
-    0x0302,0x0117, 0x0302,0x0134, 0x0302,0x0153, 0x0302,0x0157, 0x0302,0x0176, 
-    0x0306,0x0029, 0x0308,0x00b2, 0x0309,0x00dc, 0x030d,0x00f8, 0x0312,0x00f3, 
-    0x0318,0x007e, 0x031d,0x0080, 0x0321,0x0008, 0x0321,0x0094, 0x0326,0x017b, 
-    0x0326,0x0181, 0x0329,0x012e, 0x032a,0x017b, 0x032a,0x0181, 0x032e,0x008f, 
-    0x032e,0x0095, 0x032e,0x00f3, 0x032e,0x00f9, 0x0332,0x0009, 0x0331,0x0008, 
-    0x0330,0x003d, 0x0330,0x0044, 0x0330,0x0053, 0x0332,0x008f, 0x0332,0x0095, 
-    0x0330,0x00b1, 0x0332,0x00f3, 0x0332,0x00f9, 0x0330,0x0127, 0x0332,0x017b, 
-    0x0332,0x0181, 0x033c,0x0013, 0x033c,0x001c, 0x033d,0x0086, 0x033d,0x00ec, 
-    0x033d,0x0172, 0x033e,0x019d, 0x0345,0x0002, 0x0344,0x008f, 0x0344,0x00f3, 
-    0x034d,0x0030, 0x0352,0x0033, 0x0354,0x0029, 0x0354,0x0030, 0x035a,0x0009, 
-    0x035a,0x017b, 0x035a,0x019b, 0x035a,0x01a2, 0x035e,0x0181, 0x0360,0x0009, 
-    0x0366,0x0009, 0x0364,0x0029, 0x0364,0x0030, 0x0364,0x0033, 0x0364,0x003a, 
-    0x0364,0x003d, 0x0364,0x0044, 0x0369,0x0030, 0x0370,0x0029, 0x0370,0x0030, 
-    0x0376,0x0033, 0x037a,0x0009, 0x037a,0x019b, 0x037a,0x01a2, 0x037c,0x0009, 
-    0x0382,0x0181, 0x0386,0x0009, 0x0384,0x0029, 0x0384,0x0030, 0x0384,0x0033, 
-    0x0384,0x003a, 0x0384,0x003d, 0x0384,0x0044, 0x038a,0x0044, 0x038a,0x009e, 
-    0x038a,0x0106, 0x038a,0x0198, 0x038d,0x010e, 0x038d,0x0152, 0x038d,0x0158, 
-    0x0392,0x009e, 0x0392,0x0106, 0x0392,0x0198, 0x0395,0x0086, 0x0395,0x009a, 
-    0x0395,0x00ec, 0x0395,0x0172, 0x0398,0x014e, 0x0398,0x0175, 0x0398,0x018d, 
-    0x039c,0x0023, 0x039c,0x0027, 0x039c,0x00ef, 0x039c,0x0139, 0x039c,0x0168, 
-    0x03a0,0x0019, 0x03a0,0x001d, 0x03a0,0x0023, 0x03a0,0x0027, 0x03a1,0x004e, 
-    0x03a4,0x0162, 0x03a4,0x0183, 0x03a8,0x0013, 0x03a8,0x0027, 0x03a8,0x0133, 
-    0x03a8,0x0148, 0x03a8,0x0181, 0x03ac,0x0013, 0x03ac,0x0027, 0x03b0,0x017b, 
-    0x03b0,0x0181, 0x03b4,0x004b, 0x03b4,0x00e0, 0x03b4,0x00fb, 0x03b8,0x000f, 
-    0x03b8,0x0013, 0x03b8,0x00ab, 0x03b8,0x00bf, 0x03b8,0x00d0, 0x03bd,0x00da, 
-    0x03bd,0x012c, 0x03c8,0x000f, 0x03c8,0x0013, 0x03c8,0x0019, 0x03c8,0x001d, 
-    0x03cd,0x0086, 0x03cd,0x00ec, 0x03cd,0x0172, 0x03d2,0x00e0, 0x03d2,0x00ef, 
-    0x03d2,0x0112, 0x03d2,0x0139, 0x03d2,0x0168, 0x03d6,0x017b, 0x03d6,0x0181, 
-    0x03da,0x0133, 0x03da,0x0148, 0x03e2,0x0023, 0x03e2,0x0027, 0x03e6,0x0027, 
-    0x03e6,0x0181, 0x03ee,0x017b, 0x03ee,0x0181, 0x03fe,0x003d, 0x0401,0x012a, 
-    0x0401,0x019e, 0x0405,0x01a0, 0x040a,0x000d, 0x040a,0x011f, 0x040a,0x016f, 
-    0x040d,0x012a, 0x0412,0x017b, 0x041a,0x0033, 0x041a,0x003d, 0x041a,0x0181, 
-    0x0421,0x0086, 0x0421,0x009a, 0x0421,0x00ec, 0x0421,0x0172, 0x042e,0x0205, 
-    0x043a,0x0205, 0x043e,0x017b, 0x0442,0x01f5, 0x044c,0x0007, 0x0452,0x0033, 
-    0x0452,0x01ce, 0x0452,0x01d0, 0x0452,0x01f1, 0x0452,0x01fb, 0x0452,0x0225, 
-    0x0454,0x0005, 0x045a,0x0033, 0x045a,0x0181, 0x045a,0x01ce, 0x045a,0x01d0, 
-    0x045a,0x01f1, 0x0469,0x01de, 0x046e,0x0181, 0x047a,0x01ce, 0x047a,0x01f1, 
-    0x0485,0x012c, 0x0489,0x012c, 0x0490,0x01d8, 0x0496,0x0033, 0x0496,0x003d, 
-    0x0498,0x008f, 0x0498,0x00f3, 0x049e,0x0044, 0x049e,0x0221, 0x04a1,0x0006, 
-    0x04a2,0x0044, 0x04a6,0x0221, 0x04a9,0x0004, 0x04ac,0x0027, 0x04b1,0x009a, 
-    0x04b6,0x0097, 0x04b8,0x0027, 0x04c6,0x0219, 0x04ca,0x017b, 0x04cc,0x004b, 
-    0x04d0,0x00ab, 0x04d6,0x017b, 0x04d8,0x000f, 0x04d8,0x0019, 0x04d8,0x0033, 
-    0x04d8,0x003d, 0x04de,0x003d, 0x04de,0x0103, 0x04de,0x018b, 0x04de,0x0231, 
-    0x04e2,0x0044, 0x04e2,0x009e, 0x04e2,0x0106, 0x04e2,0x0198, 0x04e5,0x01a4, 
-    0x04e5,0x01b6, 0x04ea,0x009e, 0x04ea,0x0106, 0x04ea,0x0198, 0x04ed,0x002e, 
-    0x04ed,0x0038, 0x04ed,0x00a2, 0x04f1,0x0086, 0x04f1,0x009a, 0x04f1,0x00ec, 
-    0x04f1,0x0172, 0x04f9,0x004e, 0x04f8,0x0229, 0x04f8,0x022d, 0x0500,0x023e, 
-    0x0504,0x0217, 0x0510,0x00f3, 0x0514,0x0043, 0x0514,0x004d, 0x0514,0x00c3, 
-    0x0514,0x013d, 0x0514,0x0215, 0x0514,0x0232, 0x0515,0x0260, 0x0519,0x002a, 
-    0x0518,0x0030, 0x0518,0x0067, 0x0518,0x00c9, 0x0518,0x01eb, 0x0518,0x01ef, 
-    0x051c,0x0139, 0x051c,0x0168, 0x0520,0x0027, 0x0526,0x014e, 0x0526,0x0175, 
-    0x0526,0x018d, 0x052d,0x0200, 0x0532,0x0021, 0x0532,0x00bf, 0x0532,0x00d0, 
-    0x0532,0x0239, 0x0532,0x0266, 0x053d,0x0024, 0x053d,0x00da, 0x054a,0x000f, 
-    0x054a,0x00ab, 0x054a,0x023a, 0x054e,0x0043, 0x054e,0x004d, 0x054e,0x00c3, 
-    0x054e,0x013d, 0x054e,0x0215, 0x054e,0x0232, 0x054e,0x029d, 0x0552,0x014e, 
-    0x0552,0x018d, 0x0556,0x00f3, 0x0556,0x01e4, 0x055a,0x0299, 0x055d,0x0086, 
-    0x055d,0x009a, 0x055d,0x00ec, 0x055d,0x0172, 0x0566,0x01dc, 0x0566,0x02a5, 
-    0x056d,0x020a, 0x057a,0x003d, 0x057a,0x01d4, 0x057a,0x01f3, 0x0579,0x025e, 
-    0x057e,0x0139, 0x057e,0x0168, 0x0581,0x0006, 0x0586,0x017b, 0x0586,0x0181, 
-    0x0586,0x028c, 0x0588,0x0007, 0x058e,0x0033, 0x058e,0x008f, 0x058e,0x01d0, 
-    0x058e,0x027c, 0x0590,0x0003, 0x0596,0x0033, 0x0596,0x008f, 0x0596,0x0095, 
-    0x0596,0x01d0, 0x0596,0x027c, 0x05a2,0x026f, 0x05a5,0x0284, 0x05aa,0x017b, 
-    0x05ac,0x0205, 0x05b2,0x008f, 0x05b6,0x017b, 0x05b8,0x01da, 0x05c1,0x0276, 
-    0x05c6,0x0248, 0x05c8,0x0247, 0x05c8,0x027e, 0x05cc,0x003d, 0x05cc,0x01d4, 
-    0x05cc,0x01f3, 0x05d0,0x014e, 0x05d0,0x018d, 0x05da,0x00f9, 0x05dd,0x0006, 
-    0x05de,0x0044, 0x05e5,0x002e, 0x05e6,0x02f1, 0x05ea,0x01d4, 0x05ea,0x01f3, 
-    0x05ea,0x022d, 0x05ed,0x0002, 0x05f6,0x0027, 0x05fa,0x0097, 0x05fc,0x003d, 
-    0x0602,0x003d, 0x0606,0x00f3, 0x060a,0x0027, 0x060e,0x003d, 0x060e,0x0103, 
-    0x060e,0x018b, 0x060e,0x0231, 0x060e,0x02d1, 0x0611,0x01fc, 0x0611,0x0234, 
-    0x061a,0x0287, 0x061d,0x0214, 0x0621,0x01d4, 0x062a,0x0027, 0x062a,0x022d, 
-    0x062e,0x009e, 0x062e,0x0106, 0x062e,0x0198, 0x0632,0x009e, 0x0632,0x0106, 
-    0x0632,0x0198, 0x0639,0x0042, 0x0639,0x00b2, 0x0639,0x0108, 0x063d,0x01f8, 
-    0x0641,0x0086, 0x0641,0x009a, 0x0641,0x00ec, 0x0641,0x0172, 0x0645,0x0044, 
-    0x0649,0x0042, 0x0648,0x0087, 0x0648,0x00ed, 0x0648,0x0173, 0x0649,0x01a0, 
-    0x0648,0x0241, 0x0648,0x026f, 0x0648,0x02df, 0x0648,0x0307, 0x064c,0x023a, 
-    0x064c,0x02b3, 0x0651,0x0062, 0x0650,0x0217, 0x0651,0x02ac, 0x0650,0x02d6, 
-    0x0655,0x0042, 0x065d,0x0042, 0x0664,0x02b1, 0x0664,0x02ce, 0x0669,0x0238, 
-    0x066d,0x002a, 0x066c,0x0039, 0x066d,0x01f6, 0x066c,0x0213, 0x066c,0x022e, 
-    0x066d,0x02a2, 0x066c,0x02e1, 0x0671,0x002a, 0x0670,0x0030, 0x0670,0x0067, 
-    0x0670,0x00c9, 0x0670,0x01eb, 0x0670,0x01ef, 0x0670,0x02c3, 0x0675,0x0020, 
-    0x0678,0x0133, 0x0678,0x0148, 0x067c,0x0027, 0x0681,0x023a, 0x0684,0x0021, 
-    0x0684,0x00bf, 0x0684,0x00d0, 0x0689,0x01fc, 0x068e,0x0162, 0x068e,0x0183, 
-    0x0691,0x0200, 0x0696,0x0023, 0x0696,0x00e0, 0x0696,0x00fb, 0x0696,0x0268, 
-    0x069a,0x0282, 0x069d,0x007e, 0x06a2,0x004b, 0x06a2,0x023e, 0x06a2,0x02dc, 
-    0x06a6,0x0097, 0x06aa,0x02b1, 0x06aa,0x02ce, 0x06ae,0x0039, 0x06ae,0x0213, 
-    0x06ae,0x022e, 0x06ae,0x02e1, 0x06b2,0x0162, 0x06b2,0x0183, 0x06b6,0x0023, 
-    0x06b6,0x00e0, 0x06b6,0x00fb, 0x06ba,0x008f, 0x06ba,0x01e4, 0x06be,0x034b, 
-    0x06c1,0x0086, 0x06c1,0x009a, 0x06c1,0x00ec, 0x06c1,0x0172, 0x06c6,0x01da, 
-    0x06c6,0x0280, 0x06c6,0x0351, 0x06ce,0x008f, 0x06d2,0x01e3, 0x06d2,0x0287, 
-    0x06d2,0x0353, 0x06d6,0x027a, 0x06d6,0x029b, 0x06da,0x0033, 0x06da,0x01ce, 
-    0x06da,0x01f1, 0x06de,0x0133, 0x06de,0x0148, 0x06e2,0x0021, 0x06e2,0x00bf, 
-    0x06e2,0x00d0, 0x06e5,0x023a, 0x06e9,0x0004, 0x06ee,0x028c, 0x06ee,0x0338, 
-    0x06f2,0x0328, 0x06f2,0x0330, 0x06f4,0x0005, 0x06f9,0x01e0, 0x06fe,0x0328, 
-    0x06fe,0x0330, 0x0702,0x003d, 0x0702,0x00f3, 0x0702,0x0330, 0x0704,0x0003, 
-    0x070a,0x003d, 0x070a,0x00f3, 0x070a,0x01d4, 0x070a,0x01f3, 0x070a,0x0330, 
-    0x0711,0x032a, 0x0711,0x032e, 0x0716,0x003d, 0x0718,0x0205, 0x0718,0x0282, 
-    0x071e,0x00f3, 0x0720,0x01dc, 0x0720,0x02a5, 0x0726,0x0324, 0x072a,0x028a, 
-    0x072a,0x02a7, 0x0729,0x031c, 0x0729,0x032a, 0x072e,0x003d, 0x072e,0x00f9, 
-    0x072e,0x022d, 0x072e,0x0248, 0x072e,0x02e4, 0x0730,0x003d, 0x0730,0x0247, 
-    0x0730,0x02e3, 0x0730,0x0324, 0x0732,0x0324, 0x0739,0x032e, 0x073e,0x003d, 
-    0x0740,0x003d, 0x0744,0x027a, 0x0744,0x029b, 0x0748,0x0033, 0x0748,0x01ce, 
-    0x0748,0x01f1, 0x074c,0x0162, 0x074c,0x0183, 0x0750,0x0023, 0x0750,0x00e0, 
-    0x0750,0x00fb, 0x0755,0x0246, 0x075a,0x0095, 0x075a,0x0397, 0x075d,0x0004, 
-    0x076a,0x03b3, 0x076d,0x0002, 0x0772,0x02fb, 0x0772,0x0301, 0x0772,0x0315, 
-    0x0772,0x0397, 0x0776,0x008f, 0x077e,0x0027, 0x078a,0x00a1, 0x0792,0x009d, 
-    0x0792,0x00c3, 0x0792,0x02fb, 0x0792,0x0301, 0x0792,0x0315, 0x0792,0x03bd, 
-    0x0796,0x0027, 0x0796,0x024f, 0x079e,0x009d, 0x07a6,0x009d, 0x07a6,0x02fb, 
-    0x07a6,0x0301, 0x07a6,0x0315, 0x07a6,0x03bd, 0x07aa,0x0027, 0x07aa,0x024f, 
-    0x07ae,0x009d, 0x07b9,0x004e, 0x07b8,0x0087, 0x07b8,0x00ed, 0x07b8,0x0173, 
-    0x07b8,0x0197, 0x07b9,0x021a, 0x07b9,0x02b8, 0x07b9,0x0364, 0x07be,0x0029, 
-    0x07be,0x0030, 0x07c0,0x017b, 0x07c6,0x017b, 0x07c8,0x00f3, 0x07ce,0x00f3, 
-    0x07d0,0x008f, 0x07d6,0x008f, 0x07d9,0x01e8, 0x07dd,0x0292, 0x07e2,0x0053, 
-    0x07e6,0x008f, 0x07e6,0x00f3, 0x07e6,0x017b, 0x07e8,0x0029, 0x07e8,0x0030, 
-    0x07ec,0x0021, 0x07ec,0x02ad, 0x07f2,0x0181, 0x07f2,0x0315, 0x07f4,0x0021, 
-    0x07f8,0x020f, 0x07fd,0x002e, 0x0800,0x008f, 0x0805,0x0006, 0x0809,0x03c2, 
-    0x080d,0x0084, 0x0812,0x0009, 0x0811,0x0008, 0x0812,0x00f3, 0x0812,0x00f9, 
-    0x0812,0x017b, 0x0812,0x0181, 0x0814,0x0033, 0x0818,0x0023, 0x081c,0x0285, 
-    0x0826,0x03bd, 0x082c,0x008f, 0x082c,0x017b, 0x0832,0x0043, 0x0832,0x011b, 
-    0x0832,0x01b3, 0x0832,0x01c3, 0x0835,0x032a, 0x0838,0x0085, 0x0839,0x032a, 
-    0x083e,0x0049, 0x083d,0x0084, 0x083e,0x02fb, 0x083e,0x0301, 0x083e,0x0315, 
-    0x083e,0x0397, 0x0842,0x0009, 0x0841,0x0008, 0x0844,0x0009, 0x0846,0x008f, 
-    0x084a,0x0033, 0x084e,0x0285, 0x0851,0x009a, 0x0856,0x00a1, 0x0859,0x031c, 
-    0x085d,0x00b2, 0x0861,0x0012, 0x0861,0x02cc, 0x0865,0x0058, 0x0865,0x007e, 
-    0x0869,0x004a, 0x0871,0x0010, 0x0876,0x003d, 0x0879,0x032c, 0x087e,0x0089, 
-    0x0882,0x0229, 0x0882,0x022d, 0x0882,0x02c7, 0x0882,0x02cb, 0x0886,0x0021, 
-    0x0886,0x02ad, 0x0885,0x0356, 0x088a,0x0017, 0x088a,0x020f, 0x0889,0x0354, 
-    0x088d,0x009c, 0x0892,0x0089, 0x0895,0x0246, 0x089a,0x03bd, 0x089e,0x008f, 
-    0x089e,0x02f9, 0x089e,0x0313, 0x08a1,0x032a, 0x08a6,0x0053, 0x08a6,0x0095, 
-    0x08a6,0x0397, 0x08a8,0x017b, 0x08ad,0x031a, 0x08b2,0x017b, 0x08b4,0x00f3, 
-    0x08b5,0x02a0, 0x08b8,0x0089, 0x08c1,0x0024, 0x08c4,0x00f3, 0x08c9,0x007e, 
-    0x08cd,0x007c, 0x08cd,0x0222, 0x08cd,0x0294, 0x08d1,0x003a, 0x08d6,0x0009, 
-    0x08d9,0x003a, 0x08dc,0x001f, 0x08e0,0x008f, 0x08e0,0x017b, 0x08e4,0x0009, 
-    0x08e8,0x01ed, 0x08ed,0x031c, 0x08f2,0x003d, 0x08f6,0x008f, 0x08f6,0x017b, 
-    0x08fa,0x0009, 0x08fe,0x003d, 0x0902,0x01e9, 0x0904,0x01e9, 0x0904,0x0381, 
-    0x090a,0x03b1, 0x090d,0x031a, 0x0910,0x0299, 0x0914,0x034b, 0x0919,0x0008, 
-    0x091c,0x0033, 0x091c,0x003d, 0x0920,0x0027, 0x0924,0x0027, 0x0924,0x01fb, 
-    0x092a,0x01ce, 0x092a,0x01f1, 0x092d,0x031c, 0x0930,0x001f, 0x0936,0x00c5, 
-    0x0938,0x00c5, 0x0938,0x0381, 0x093c,0x001b, 0x0942,0x017d, 0x094a,0x0027, 
-    0x094e,0x0027, 0x094e,0x01fb, 0x0952,0x03b1, 0x095a,0x0029, 0x095a,0x0030, 
-    0x095d,0x0030, 0x0961,0x0030, 0x0966,0x02f9, 0x0966,0x0313, 0x0968,0x02eb, 
-    0x096d,0x0008, 0x0970,0x017b, 0x0974,0x0033, 0x0979,0x0150, 0x097d,0x009a, 
-    0x0982,0x0293, 0x0984,0x0293, 0x0984,0x0379, 0x098a,0x02eb, 0x098e,0x0009, 
-    0x0992,0x003d, 0x0996,0x003d, 0x0999,0x0062, 0x099e,0x003d, 0x09a0,0x0027, 
-    0x09a5,0x0144, 0x09a8,0x02b5, 0x09ae,0x008f, 0x09ae,0x009d, 0x09b2,0x004d, 
-    0x09b2,0x0053, 0x09b2,0x00c3, 0x09b2,0x013d, 0x09b2,0x01c5, 0x09b2,0x0271, 
-    0x09b4,0x0025, 0x09ba,0x0033, 0x09ba,0x0079, 0x09bc,0x0015, 0x09c2,0x013f, 
-    0x09c4,0x013f, 0x09c4,0x0379, 0x09ca,0x02b5, 0x09cd,0x0006, 0x09da,0x0009, 
-    0x09d9,0x0008, 0x09dc,0x000b, 0x09dc,0x004f, 0x09dd,0x0086, 0x09e0,0x0009, 
-    0x09e6,0x00a1, 0x09e8,0x0009, 0x09ed,0x0086, 0x09f2,0x001f, 0x09f2,0x002f, 
-    0x09f2,0x0049, 0x09f2,0x006f, 0x09f2,0x0085, 0x09f2,0x0091, 0x09f2,0x00a9, 
-    0x09f2,0x00d3, 0x09f2,0x00d7, 0x09f2,0x011d, 0x09f2,0x0121, 0x09f2,0x0235, 
-    0x09f2,0x0393, 0x09f6,0x0324, 0x09f8,0x0049, 0x09f8,0x00a9, 0x09f8,0x011d, 
-    0x09fe,0x001f, 0x09fe,0x0029, 0x09fe,0x0033, 0x09fe,0x003d, 0x09fe,0x0085, 
-    0x09fe,0x008f, 0x09fe,0x00d3, 0x0a00,0x003d, 0x0a06,0x012d, 0x0a0e,0x00b3, 
-    0x0a10,0x000b, 0x0a10,0x0387, 0x0a16,0x0059, 0x0a18,0x0009, 0x0a1e,0x0043, 
-    0x0a24,0x0085, 0x0a2a,0x0009, 0x0a2d,0x0008, 0x0a32,0x028a, 0x0a32,0x02a7, 
-    0x0a31,0x031c, 0x0a35,0x032e, 0x0a39,0x0006, 0x0a3a,0x0105, 0x0a3a,0x024f, 
-    0x0a3c,0x0299, 0x0a42,0x01ed, 0x0a46,0x0299, 0x0a48,0x01ed, 0x0a4c,0x0059, 
-    0x0a52,0x000b, 0x0a52,0x0387, 0x0a56,0x000b, 0x0a5e,0x0009, 0x0a60,0x003d, 
-    0x0a66,0x0105, 0x0a6a,0x0195, 0x0a6c,0x000b, 0x0a76,0x0053, 0x0a78,0x0009, 
-    0x0a7a,0x008f, 0x0a82,0x0299, 0x0a86,0x01ed, 0x0a8a,0x0027, 0x0a8e,0x004b, 
-    0x0a92,0x003d, 0x0a95,0x0322, 0x0a99,0x0038, 0x0a99,0x0090, 0x0a9c,0x0061, 
-    0x0a9c,0x00c7, 0x0a9c,0x012d, 0x0a9c,0x016f, 0x0a9c,0x017d, 0x0a9c,0x02c9, 
-    0x0a9c,0x0383, 0x0aa1,0x0010, 0x0aa4,0x00b3, 0x0aa8,0x002f, 0x0aac,0x0027, 
-    0x0ab0,0x004b, 0x0ab4,0x0043, 0x0ab9,0x0090, 0x0abd,0x0010, 0x0ac4,0x0019, 
-    0x0acc,0x00f5, 0x0acc,0x022b, 0x0acc,0x037b, 0x0ad2,0x008f, 0x0ad2,0x01f1, 
-    0x0ad6,0x0324, 0x0ad9,0x0330, 0x0ade,0x008f, 0x0ade,0x01f1, 0x0ae0,0x017b, 
-    0x0ae4,0x008f, 0x0ae9,0x004e, 0x0aee,0x0027, 0x0af2,0x028a, 0x0af2,0x02a7, 
-    0x0af1,0x031c, 0x0af6,0x0027, 0x0af9,0x031c, 0x0afe,0x00e9, 0x0afe,0x02bb, 
-    0x0b02,0x000b, 0x0b06,0x00f5, 0x0b06,0x022b, 0x0b06,0x037b, 0x0b0a,0x003d, 
-    0x0000,0x0000 
-};
-
+ABC_NAMESPACE_IMPL_END
 
diff --git a/src/opt/sim/sim.h b/src/opt/sim/sim.h
index 89eaafac..e1a34273 100644
--- a/src/opt/sim/sim.h
+++ b/src/opt/sim/sim.h
@@ -21,6 +21,7 @@
 #ifndef __SIM_H__
 #define __SIM_H__
 
+
 /*
     The ideas realized in this package are described in the paper:
     "Detecting Symmetries in Boolean Functions using Circuit Representation, 
@@ -35,9 +36,10 @@
 ///                         PARAMETERS                               ///
 ////////////////////////////////////////////////////////////////////////
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+
+
+ABC_NAMESPACE_HEADER_START
+
 
 ////////////////////////////////////////////////////////////////////////
 ///                         BASIC TYPES                              ///
@@ -197,15 +199,15 @@ extern void            Sim_SymmsStructCompute( Abc_Ntk_t * pNtk, Vec_Ptr_t * vMa
 /*=== simSymSim.c ==========================================================*/
 extern void            Sim_SymmsSimulate( Sym_Man_t * p, unsigned * pPatRand, Vec_Ptr_t * vMatrsNonSym );
 /*=== simUtil.c ==========================================================*/
-extern Vec_Ptr_t *     Sim_UtilInfoAlloc( int nSize, int nWords, bool fClean );
+extern Vec_Ptr_t *     Sim_UtilInfoAlloc( int nSize, int nWords, int  fClean );
 extern void            Sim_UtilInfoFree( Vec_Ptr_t * p );
 extern void            Sim_UtilInfoAdd( unsigned * pInfo1, unsigned * pInfo2, int nWords );
 extern void            Sim_UtilInfoDetectDiffs( unsigned * pInfo1, unsigned * pInfo2, int nWords, Vec_Int_t * vDiffs );
 extern void            Sim_UtilInfoDetectNews( unsigned * pInfo1, unsigned * pInfo2, int nWords, Vec_Int_t * vDiffs );
 extern void            Sim_UtilInfoFlip( Sim_Man_t * p, Abc_Obj_t * pNode );
-extern bool            Sim_UtilInfoCompare( Sim_Man_t * p, Abc_Obj_t * pNode );
-extern void            Sim_UtilSimulate( Sim_Man_t * p, bool fFirst );
-extern void            Sim_UtilSimulateNode( Sim_Man_t * p, Abc_Obj_t * pNode, bool fType, bool fType1, bool fType2 );
+extern int             Sim_UtilInfoCompare( Sim_Man_t * p, Abc_Obj_t * pNode );
+extern void            Sim_UtilSimulate( Sim_Man_t * p, int  fFirst );
+extern void            Sim_UtilSimulateNode( Sim_Man_t * p, Abc_Obj_t * pNode, int  fType, int  fType1, int  fType2 );
 extern void            Sim_UtilSimulateNodeOne( Abc_Obj_t * pNode, Vec_Ptr_t * vSimInfo, int nSimWords, int nOffset );
 extern void            Sim_UtilTransferNodeOne( Abc_Obj_t * pNode, Vec_Ptr_t * vSimInfo, int nSimWords, int nOffset, int fShift );
 extern int             Sim_UtilCountSuppSizes( Sim_Man_t * p, int fStruct );
@@ -221,9 +223,11 @@ extern int             Sim_UtilCountAllPairs( Vec_Ptr_t * vSuppFun, int nSimWord
 extern void            Sim_UtilCountPairsAll( Sym_Man_t * p );
 extern int             Sim_UtilMatrsAreDisjoint( Sym_Man_t * p );
 
-#ifdef __cplusplus
-}
-#endif
+
+
+ABC_NAMESPACE_HEADER_END
+
+
 
 #endif
 
diff --git a/src/opt/sim/simMan.c b/src/opt/sim/simMan.c
index 6a86e25f..234aa412 100644
--- a/src/opt/sim/simMan.c
+++ b/src/opt/sim/simMan.c
@@ -21,6 +21,9 @@
 #include "abc.h"
 #include "sim.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -102,8 +105,8 @@ void Sym_ManStop( Sym_Man_t * p )
     if ( p->vSupports )    Vec_VecFree( p->vSupports );
     for ( i = 0; i < p->nOutputs; i++ )
     {
-        Extra_BitMatrixStop( p->vMatrSymms->pArray[i] );
-        Extra_BitMatrixStop( p->vMatrNonSymms->pArray[i] );
+        Extra_BitMatrixStop( (Extra_BitMat_t *)p->vMatrSymms->pArray[i] );
+        Extra_BitMatrixStop( (Extra_BitMat_t *)p->vMatrNonSymms->pArray[i] );
     }
     Vec_IntFree( p->vVarsU );
     Vec_IntFree( p->vVarsV );
@@ -286,3 +289,5 @@ void Sim_ManPatFree( Sim_Man_t * p, Sim_Pat_t * pPat )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/sim/simSat.c b/src/opt/sim/simSat.c
index d514f7f2..29fc6975 100644
--- a/src/opt/sim/simSat.c
+++ b/src/opt/sim/simSat.c
@@ -21,6 +21,9 @@
 #include "abc.h"
 #include "sim.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -46,3 +49,5 @@
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/sim/simSeq.c b/src/opt/sim/simSeq.c
index 49fb939f..db05226f 100644
--- a/src/opt/sim/simSeq.c
+++ b/src/opt/sim/simSeq.c
@@ -21,6 +21,9 @@
 #include "abc.h"
 #include "sim.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -169,3 +172,5 @@ void Sim_SimulateSeqFrame( Vec_Ptr_t * vInfo, Abc_Ntk_t * pNtk, int iFrames, int
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/sim/simSupp.c b/src/opt/sim/simSupp.c
index f84fedc4..563f98ac 100644
--- a/src/opt/sim/simSupp.c
+++ b/src/opt/sim/simSupp.c
@@ -22,12 +22,15 @@
 #include "fraig.h"
 #include "sim.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
  
-static int    Sim_ComputeSuppRound( Sim_Man_t * p, bool fUseTargets );
-static int    Sim_ComputeSuppRoundNode( Sim_Man_t * p, int iNumCi, bool fUseTargets );
+static int    Sim_ComputeSuppRound( Sim_Man_t * p, int  fUseTargets );
+static int    Sim_ComputeSuppRoundNode( Sim_Man_t * p, int iNumCi, int  fUseTargets );
 static void   Sim_ComputeSuppSetTargets( Sim_Man_t * p );
 
 static void   Sim_UtilAssignRandom( Sim_Man_t * p );
@@ -68,17 +71,17 @@ Vec_Ptr_t * Sim_ComputeStrSupp( Abc_Ntk_t * pNtk )
     {
 //        if ( Abc_NodeIsConst(pNode) )
 //            continue;
-        pSimmNode  = vSuppStr->pArray[ pNode->Id ];
-        pSimmNode1 = vSuppStr->pArray[ Abc_ObjFaninId0(pNode) ];
-        pSimmNode2 = vSuppStr->pArray[ Abc_ObjFaninId1(pNode) ];
+        pSimmNode  = (unsigned *)vSuppStr->pArray[ pNode->Id ];
+        pSimmNode1 = (unsigned *)vSuppStr->pArray[ Abc_ObjFaninId0(pNode) ];
+        pSimmNode2 = (unsigned *)vSuppStr->pArray[ Abc_ObjFaninId1(pNode) ];
         for ( k = 0; k < nSuppWords; k++ )
             pSimmNode[k] = pSimmNode1[k] | pSimmNode2[k];
     }
     // set the structural supports of the PO nodes
     Abc_NtkForEachCo( pNtk, pNode, i )
     {
-        pSimmNode  = vSuppStr->pArray[ pNode->Id ];
-        pSimmNode1 = vSuppStr->pArray[ Abc_ObjFaninId0(pNode) ];
+        pSimmNode  = (unsigned *)vSuppStr->pArray[ pNode->Id ];
+        pSimmNode1 = (unsigned *)vSuppStr->pArray[ Abc_ObjFaninId0(pNode) ];
         for ( k = 0; k < nSuppWords; k++ )
             pSimmNode[k] = pSimmNode1[k];
     }
@@ -165,7 +168,7 @@ p->timeTotal = clock() - clk;
   SeeAlso     []
 
 ***********************************************************************/
-int Sim_ComputeSuppRound( Sim_Man_t * p, bool fUseTargets )
+int Sim_ComputeSuppRound( Sim_Man_t * p, int  fUseTargets )
 {
     Vec_Int_t * vTargets;
     int i, Counter = 0;
@@ -177,7 +180,7 @@ p->timeSim += clock() - clk;
     // iterate through the CIs and detect COs that depend on them
     for ( i = p->iInput; i < p->nInputs; i++ )
     {
-        vTargets = p->vSuppTargs->pArray[i];
+        vTargets = (Vec_Int_t *)p->vSuppTargs->pArray[i];
         if ( fUseTargets && vTargets->nSize == 0 )
             continue;
         Counter += Sim_ComputeSuppRoundNode( p, i, fUseTargets );
@@ -196,7 +199,7 @@ p->timeSim += clock() - clk;
   SeeAlso     []
 
 ***********************************************************************/
-int Sim_ComputeSuppRoundNode( Sim_Man_t * p, int iNumCi, bool fUseTargets )
+int Sim_ComputeSuppRoundNode( Sim_Man_t * p, int iNumCi, int  fUseTargets )
 {
     int fVerbose = 0;
     Sim_Pat_t * pPat;
@@ -217,7 +220,7 @@ p->timeTrav += clock() - clk;
     // complement the simulation info of the selected CI
     Sim_UtilInfoFlip( p, pNodeCi );
     // simulate the levelized structure of nodes
-    Vec_VecForEachEntry( vNodesByLevel, pNode, i, k )
+    Vec_VecForEachEntry( Abc_Obj_t *, vNodesByLevel, pNode, i, k )
     {
         fType0 = Abc_NodeIsTravIdCurrent( Abc_ObjFanin0(pNode) );
         fType1 = Abc_NodeIsTravIdCurrent( Abc_ObjFanin1(pNode) );
@@ -228,7 +231,7 @@ p->timeSim += clock() - clk;
     // set the simulation info of the affected COs
     if ( fUseTargets )
     {
-        vTargets = p->vSuppTargs->pArray[iNumCi];
+        vTargets = (Vec_Int_t *)p->vSuppTargs->pArray[iNumCi];
         for ( i = vTargets->nSize - 1; i >= 0; i-- )
         {
             // get the target output
@@ -253,7 +256,7 @@ if ( fVerbose )
             Sim_SuppFunSetVar( p->vSuppFun, Output, iNumCi );
             
             // detect the differences in the simulation info
-            Sim_UtilInfoDetectDiffs( p->vSim0->pArray[pNode->Id], p->vSim1->pArray[pNode->Id], p->nSimWords, p->vDiffs );
+            Sim_UtilInfoDetectDiffs( (unsigned *)p->vSim0->pArray[pNode->Id], (unsigned *)p->vSim1->pArray[pNode->Id], p->nSimWords, p->vDiffs );
             // create new patterns
             if ( !fFirst && p->vFifo->nSize > 1000 )
                 continue;
@@ -314,8 +317,8 @@ void Sim_ComputeSuppSetTargets( Sim_Man_t * p )
     int i, k, Num;
     Abc_NtkForEachCo( p->pNtk, pNode, i )
     {
-        pSuppStr = p->vSuppStr->pArray[pNode->Id];
-        pSuppFun = p->vSuppFun->pArray[i];
+        pSuppStr = (unsigned *)p->vSuppStr->pArray[pNode->Id];
+        pSuppFun = (unsigned *)p->vSuppFun->pArray[i];
         // find vars in the structural support that are not in the functional support
         Sim_UtilInfoDetectNews( pSuppFun, pSuppStr, p->nSuppWords, p->vDiffs );
         Vec_IntForEachEntry( p->vDiffs, Num, k )
@@ -342,7 +345,7 @@ void Sim_UtilAssignRandom( Sim_Man_t * p )
     // assign the random/systematic simulation info to the PIs
     Abc_NtkForEachCi( p->pNtk, pNode, i )
     {
-        pSimInfo = p->vSim0->pArray[pNode->Id];
+        pSimInfo = (unsigned *)p->vSim0->pArray[pNode->Id];
         for ( k = 0; k < p->nSimWords; k++ )
             pSimInfo[k] = SIM_RANDOM_UNSIGNED;
     }
@@ -373,7 +376,7 @@ void Sim_UtilAssignFromFifo( Sim_Man_t * p )
     {
         ++Counter;
         // get the pattern
-        pPat = Vec_PtrPop( p->vFifo );
+        pPat = (Sim_Pat_t *)Vec_PtrPop( p->vFifo );
         if ( fUseOneWord )
         {
             // get the first word of the next series
@@ -385,7 +388,7 @@ void Sim_UtilAssignFromFifo( Sim_Man_t * p )
             Abc_NtkForEachCi( p->pNtk, pNode, i )
             {
                 pNode = Abc_NtkCi(p->pNtk,i);
-                pSimInfo = p->vSim0->pArray[pNode->Id];
+                pSimInfo = (unsigned *)p->vSim0->pArray[pNode->Id];
                 if ( Sim_HasBit(pPat->pData, i) )
                     pSimInfo[iWord] = SIM_MASK_FULL;
                 else
@@ -405,7 +408,7 @@ void Sim_UtilAssignFromFifo( Sim_Man_t * p )
             // set the pattern for all CIs from iWord to iWord + nWordsNew
             Abc_NtkForEachCi( p->pNtk, pNode, i )
             {
-                pSimInfo = p->vSim0->pArray[pNode->Id];
+                pSimInfo = (unsigned *)p->vSim0->pArray[pNode->Id];
                 if ( Sim_HasBit(pPat->pData, i) )
                 {
                     for ( w = iWord; w < iWordLim; w++ )
@@ -457,7 +460,7 @@ void Sim_SolveTargetsUsingSat( Sim_Man_t * p, int Limit )
 
     p->nSatRuns = 0;
     // put targets into one array
-    Vec_VecForEachEntryReverse( p->vSuppTargs, pEntry, Input, k )
+    Vec_VecForEachEntryReverse( void *, p->vSuppTargs, pEntry, Input, k )
     {
         p->nSatRuns++;
         Output = (int)(ABC_PTRUINT_T)pEntry;
@@ -470,7 +473,7 @@ void Sim_SolveTargetsUsingSat( Sim_Man_t * p, int Limit )
         Params.nSeconds = ABC_INFINITY;
         Params.fInternal = 1;
 clk = clock();
-        pMan = Abc_NtkToFraig( pMiter, &Params, 0, 0 ); 
+        pMan = (Fraig_Man_t *)Abc_NtkToFraig( pMiter, &Params, 0, 0 ); 
 p->timeFraig += clock() - clk;
 clk = clock();
         Fraig_ManProveMiter( pMan );
@@ -483,7 +486,7 @@ p->timeSat += clock() - clk;
         {
             p->nSatRunsUnsat++;
             pModel = NULL;
-            Vec_PtrRemove( p->vSuppTargs->pArray[Input], pEntry );
+            Vec_PtrRemove( (Vec_Ptr_t *)p->vSuppTargs->pArray[Input], pEntry );
         }
         else // sat
         {
@@ -595,3 +598,5 @@ int Sim_SolveSuppModelVerify( Abc_Ntk_t * pNtk, int * pModel, int Input, int Out
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/sim/simSwitch.c b/src/opt/sim/simSwitch.c
index baabc320..4f675082 100644
--- a/src/opt/sim/simSwitch.c
+++ b/src/opt/sim/simSwitch.c
@@ -21,6 +21,9 @@
 #include "abc.h"
 #include "sim.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -64,15 +67,15 @@ Vec_Int_t * Sim_NtkComputeSwitching( Abc_Ntk_t * pNtk, int nPatterns )
     pSwitching = (float *)vSwitching->pArray;
     Abc_NtkForEachCi( pNtk, pNode, i )
     {
-        pSimInfo = Vec_PtrEntry(vSimInfo, pNode->Id);
+        pSimInfo = (unsigned *)Vec_PtrEntry(vSimInfo, pNode->Id);
         Sim_UtilSetRandom( pSimInfo, nSimWords );
         pSwitching[pNode->Id] = Sim_ComputeSwitching( pSimInfo, nSimWords );
     }
     // simulate the internal nodes
     vNodes  = Abc_AigDfs( pNtk, 1, 0 );
-    Vec_PtrForEachEntry( vNodes, pNode, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pNode, i )
     {
-        pSimInfo = Vec_PtrEntry(vSimInfo, pNode->Id);
+        pSimInfo = (unsigned *)Vec_PtrEntry(vSimInfo, pNode->Id);
         Sim_UtilSimulateNodeOne( pNode, vSimInfo, nSimWords, 0 );
         pSwitching[pNode->Id] = Sim_ComputeSwitching( pSimInfo, nSimWords );
     }
@@ -105,3 +108,5 @@ float Sim_ComputeSwitching( unsigned * pSimInfo, int nSimWords )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/sim/simSym.c b/src/opt/sim/simSym.c
index 71de5b05..d8a1eb4f 100644
--- a/src/opt/sim/simSym.c
+++ b/src/opt/sim/simSym.c
@@ -21,6 +21,9 @@
 #include "abc.h"
 #include "sim.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -140,3 +143,5 @@ p->timeTotal = clock() - clkTotal;
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/sim/simSymSat.c b/src/opt/sim/simSymSat.c
index 7690a891..4f6690e5 100644
--- a/src/opt/sim/simSymSat.c
+++ b/src/opt/sim/simSymSat.c
@@ -22,6 +22,9 @@
 #include "sim.h"
 #include "fraig.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -55,11 +58,11 @@ int Sim_SymmsGetPatternUsingSat( Sym_Man_t * p, unsigned * pPattern )
     // iterate through outputs
     for ( out = p->iOutput; out < p->nOutputs; out++ )
     {
-        pMatSym    = Vec_PtrEntry( p->vMatrSymms,    out );
-        pMatNonSym = Vec_PtrEntry( p->vMatrNonSymms, out );
+        pMatSym    = (Extra_BitMat_t *)Vec_PtrEntry( p->vMatrSymms,    out );
+        pMatNonSym = (Extra_BitMat_t *)Vec_PtrEntry( p->vMatrNonSymms, out );
 
         // go through the remaining variable pairs
-        vSupport = Vec_VecEntry( p->vSupports, out );
+        vSupport = (Vec_Int_t *)Vec_VecEntry( p->vSupports, out );
         Vec_IntForEachEntry( vSupport, v, Index1 )
         Vec_IntForEachEntryStart( vSupport, u, Index2, Index1+1 )
         {
@@ -147,7 +150,7 @@ int Sim_SymmsSatProveOne( Sym_Man_t * p, int Out, int Var1, int Var2, unsigned *
     Params.nSeconds = ABC_INFINITY;
 
 clk = clock();
-    pMan = Abc_NtkToFraig( pMiter, &Params, 0, 0 ); 
+    pMan = (Fraig_Man_t *)Abc_NtkToFraig( pMiter, &Params, 0, 0 ); 
 p->timeFraig += clock() - clk;
 clk = clock();
     Fraig_ManProveMiter( pMan );
@@ -197,3 +200,5 @@ p->timeSat += clock() - clk;
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/sim/simSymSim.c b/src/opt/sim/simSymSim.c
index 2282825b..85ba56fb 100644
--- a/src/opt/sim/simSymSim.c
+++ b/src/opt/sim/simSymSim.c
@@ -21,6 +21,9 @@
 #include "abc.h"
 #include "sim.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -53,7 +56,7 @@ void Sim_SymmsSimulate( Sym_Man_t * p, unsigned * pPat, Vec_Ptr_t * vMatrsNonSym
     Sim_SymmsCreateSquare( p, pPat );
     // simulate each node in the DFS order
 clk = clock();
-    Vec_PtrForEachEntry( p->vNodes, pNode, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, p->vNodes, pNode, i )
     {
 //        if ( Abc_NodeIsConst(pNode) )
 //            continue;
@@ -97,7 +100,7 @@ void Sim_SymmsCreateSquare( Sym_Man_t * p, unsigned * pPat )
     // for each PI var copy the pattern
     Abc_NtkForEachCi( p->pNtk, pNode, i )
     {
-        pSimInfo = Vec_PtrEntry( p->vSim, pNode->Id );
+        pSimInfo = (unsigned *)Vec_PtrEntry( p->vSim, pNode->Id );
         if ( Sim_HasBit(pPat, i) )
         {
             for ( w = 0; w < p->nSimWords; w++ )
@@ -132,10 +135,10 @@ void Sim_SymmsDeriveInfo( Sym_Man_t * p, unsigned * pPat, Abc_Obj_t * pNode, Vec
     unsigned * pSimInfo;
     int i, w, Index;
     // get the matrix, the support, and the simulation info
-    pMat = Vec_PtrEntry( vMatrsNonSym, Output );
-    vSupport = Vec_VecEntry( p->vSupports, Output );
-    pSupport = Vec_PtrEntry( p->vSuppFun, Output );
-    pSimInfo = Vec_PtrEntry( p->vSim, pNode->Id );
+    pMat = (Extra_BitMat_t *)Vec_PtrEntry( vMatrsNonSym, Output );
+    vSupport = (Vec_Int_t *)Vec_VecEntry( p->vSupports, Output );
+    pSupport = (unsigned *)Vec_PtrEntry( p->vSuppFun, Output );
+    pSimInfo = (unsigned *)Vec_PtrEntry( p->vSim, pNode->Id );
     // generate vectors A1 and A2
     for ( w = 0; w < p->nSimWords; w++ )
     {
@@ -171,3 +174,5 @@ void Sim_SymmsDeriveInfo( Sym_Man_t * p, unsigned * pPat, Abc_Obj_t * pNode, Vec
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/sim/simSymStr.c b/src/opt/sim/simSymStr.c
index 9ff2f590..e9a25905 100644
--- a/src/opt/sim/simSymStr.c
+++ b/src/opt/sim/simSymStr.c
@@ -21,6 +21,9 @@
 #include "abc.h"
 #include "sim.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -72,7 +75,7 @@ void Sim_SymmsStructCompute( Abc_Ntk_t * pNtk, Vec_Ptr_t * vMatrs, Vec_Ptr_t * v
     pMap = Sim_SymmsCreateMap( pNtk );
     // collect the nodes in the TFI cone of this output
     vNodes = Abc_NtkDfs( pNtk, 0 );
-    Vec_PtrForEachEntry( vNodes, pTemp, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pTemp, i )
     {
 //        if ( Abc_NodeIsConst(pTemp) )
 //            continue;
@@ -85,14 +88,14 @@ void Sim_SymmsStructCompute( Abc_Ntk_t * pNtk, Vec_Ptr_t * vMatrs, Vec_Ptr_t * v
         pTemp = Abc_ObjFanin0(pTemp);
         if ( Abc_ObjIsCi(pTemp) || Abc_AigNodeIsConst(pTemp) )
             continue;
-        Sim_SymmsTransferToMatrix( Vec_PtrEntry(vMatrs, i), SIM_READ_SYMMS(pTemp), Vec_PtrEntry(vSuppFun, i) );
+        Sim_SymmsTransferToMatrix( (Extra_BitMat_t *)Vec_PtrEntry(vMatrs, i), SIM_READ_SYMMS(pTemp), (unsigned *)Vec_PtrEntry(vSuppFun, i) );
     }
     // clean the intermediate results
     Sim_UtilInfoFree( pNtk->vSupps );
     pNtk->vSupps = NULL;
     Abc_NtkForEachCi( pNtk, pTemp, i )
         Vec_IntFree( SIM_READ_SYMMS(pTemp) );
-    Vec_PtrForEachEntry( vNodes, pTemp, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pTemp, i )
 //        if ( !Abc_NodeIsConst(pTemp) )
             Vec_IntFree( SIM_READ_SYMMS(pTemp) );
     Vec_PtrFree( vNodes );
@@ -137,7 +140,7 @@ void Sim_SymmsStructComputeOne( Abc_Ntk_t * pNtk, Abc_Obj_t * pNode, int * pMap
     // add symmetries from other inputs
     for ( i = 0; i < vNodesOther->nSize; i++ )
     {
-        pTemp = Abc_ObjRegular(vNodesOther->pArray[i]);
+        pTemp = Abc_ObjRegular((Abc_Obj_t *)vNodesOther->pArray[i]);
         Sim_SymmsAppendFromNode( pNtk, SIM_READ_SYMMS(pTemp), vNodesOther, vNodesPi0, vNodesPi1, vSymms, pMap );
     }
     Vec_PtrFree( vNodes );
@@ -196,7 +199,7 @@ void Sim_SymmsPartitionNodes( Vec_Ptr_t * vNodes, Vec_Ptr_t * vNodesPis0,
 {
     Abc_Obj_t * pNode;
     int i;
-    Vec_PtrForEachEntry( vNodes, pNode, i )
+    Vec_PtrForEachEntry( Abc_Obj_t *, vNodes, pNode, i )
     {
         if ( !Abc_ObjIsCi(Abc_ObjRegular(pNode)) )
             Vec_PtrPush( vNodesOther, pNode );
@@ -232,8 +235,8 @@ void Sim_SymmsAppendFromGroup( Abc_Ntk_t * pNtk, Vec_Ptr_t * vNodesPi, Vec_Ptr_t
     for ( k = i+1; k < vNodesPi->nSize; k++ )
     {
         // get the two PI nodes
-        pNode1 = Abc_ObjRegular(vNodesPi->pArray[i]);
-        pNode2 = Abc_ObjRegular(vNodesPi->pArray[k]);
+        pNode1 = Abc_ObjRegular((Abc_Obj_t *)vNodesPi->pArray[i]);
+        pNode2 = Abc_ObjRegular((Abc_Obj_t *)vNodesPi->pArray[k]);
         assert( pMap[pNode1->Id] != pMap[pNode2->Id] );
         assert( pMap[pNode1->Id] >= 0 );
         assert( pMap[pNode2->Id] >= 0 );
@@ -310,7 +313,7 @@ int Sim_SymmsIsCompatibleWithNodes( Abc_Ntk_t * pNtk, unsigned uSymm, Vec_Ptr_t
     // if they belong, but are not part of symmetry, quit
     for ( i = 0; i < vNodesOther->nSize; i++ )
     {
-        pNode = Abc_ObjRegular(vNodesOther->pArray[i]);
+        pNode = Abc_ObjRegular((Abc_Obj_t *)vNodesOther->pArray[i]);
         fIsVar1 = Sim_SuppStrHasVar( pNtk->vSupps, pNode, Ind1 );
         fIsVar2 = Sim_SuppStrHasVar( pNtk->vSupps, pNode, Ind2 );
 
@@ -357,7 +360,7 @@ int Sim_SymmsIsCompatibleWithGroup( unsigned uSymm, Vec_Ptr_t * vNodesPi, int *
     fHasVar1 = fHasVar2 = 0;
     for ( i = 0; i < vNodesPi->nSize; i++ )
     {
-        pNode = Abc_ObjRegular(vNodesPi->pArray[i]);
+        pNode = Abc_ObjRegular((Abc_Obj_t *)vNodesPi->pArray[i]);
         if ( pMap[pNode->Id] == Ind1 )
             fHasVar1 = 1;
         else if ( pMap[pNode->Id] == Ind2 )
@@ -486,3 +489,5 @@ int * Sim_SymmsCreateMap( Abc_Ntk_t * pNtk )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+
diff --git a/src/opt/sim/simUtils.c b/src/opt/sim/simUtils.c
index dba487d8..25d4cd44 100644
--- a/src/opt/sim/simUtils.c
+++ b/src/opt/sim/simUtils.c
@@ -21,6 +21,9 @@
 #include "abc.h"
 #include "sim.h"
 
+ABC_NAMESPACE_IMPL_START
+
+
 ////////////////////////////////////////////////////////////////////////
 ///                        DECLARATIONS                              ///
 ////////////////////////////////////////////////////////////////////////
@@ -51,7 +54,7 @@ static int bit_count[256] = {
   SeeAlso     []
 
 ***********************************************************************/
-Vec_Ptr_t * Sim_UtilInfoAlloc( int nSize, int nWords, bool fClean )
+Vec_Ptr_t * Sim_UtilInfoAlloc( int nSize, int nWords, int fClean )
 {
     Vec_Ptr_t * vInfo;
     int i;
@@ -162,8 +165,8 @@ void Sim_UtilInfoFlip( Sim_Man_t * p, Abc_Obj_t * pNode )
 {
     unsigned * pSimInfo1, * pSimInfo2;
     int k;
-    pSimInfo1 = p->vSim0->pArray[pNode->Id];
-    pSimInfo2 = p->vSim1->pArray[pNode->Id];
+    pSimInfo1 = (unsigned *)p->vSim0->pArray[pNode->Id];
+    pSimInfo2 = (unsigned *)p->vSim1->pArray[pNode->Id];
     for ( k = 0; k < p->nSimWords; k++ )
         pSimInfo2[k] = ~pSimInfo1[k];
 }
@@ -179,12 +182,12 @@ void Sim_UtilInfoFlip( Sim_Man_t * p, Abc_Obj_t * pNode )
   SeeAlso     []
 
 ***********************************************************************/
-bool Sim_UtilInfoCompare( Sim_Man_t * p, Abc_Obj_t * pNode )
+int Sim_UtilInfoCompare( Sim_Man_t * p, Abc_Obj_t * pNode )
 {
     unsigned * pSimInfo1, * pSimInfo2;
     int k;
-    pSimInfo1 = p->vSim0->pArray[pNode->Id];
-    pSimInfo2 = p->vSim1->pArray[pNode->Id];
+    pSimInfo1 = (unsigned *)p->vSim0->pArray[pNode->Id];
+    pSimInfo2 = (unsigned *)p->vSim1->pArray[pNode->Id];
     for ( k = 0; k < p->nSimWords; k++ )
         if ( pSimInfo2[k] != pSimInfo1[k] )
             return 0;
@@ -202,7 +205,7 @@ bool Sim_UtilInfoCompare( Sim_Man_t * p, Abc_Obj_t * pNode )
   SeeAlso     []
 
 ***********************************************************************/
-void Sim_UtilSimulate( Sim_Man_t * p, bool fType )
+void Sim_UtilSimulate( Sim_Man_t * p, int fType )
 {
     Abc_Obj_t * pNode;
     int i;
@@ -225,7 +228,7 @@ void Sim_UtilSimulate( Sim_Man_t * p, bool fType )
   SeeAlso     []
 
 ***********************************************************************/
-void Sim_UtilSimulateNode( Sim_Man_t * p, Abc_Obj_t * pNode, bool fType, bool fType1, bool fType2 )
+void Sim_UtilSimulateNode( Sim_Man_t * p, Abc_Obj_t * pNode, int fType, int fType1, int fType2 )
 {
     unsigned * pSimmNode, * pSimmNode1, * pSimmNode2;
     int k, fComp1, fComp2;
@@ -233,19 +236,19 @@ void Sim_UtilSimulateNode( Sim_Man_t * p, Abc_Obj_t * pNode, bool fType, bool fT
     if ( Abc_ObjIsNode(pNode) )
     {
         if ( fType )
-            pSimmNode  = p->vSim1->pArray[ pNode->Id ];
+            pSimmNode  = (unsigned *)p->vSim1->pArray[ pNode->Id ];
         else
-            pSimmNode  = p->vSim0->pArray[ pNode->Id ];
+            pSimmNode  = (unsigned *)p->vSim0->pArray[ pNode->Id ];
 
         if ( fType1 )
-            pSimmNode1 = p->vSim1->pArray[ Abc_ObjFaninId0(pNode) ];
+            pSimmNode1 = (unsigned *)p->vSim1->pArray[ Abc_ObjFaninId0(pNode) ];
         else
-            pSimmNode1 = p->vSim0->pArray[ Abc_ObjFaninId0(pNode) ];
+            pSimmNode1 = (unsigned *)p->vSim0->pArray[ Abc_ObjFaninId0(pNode) ];
 
         if ( fType2 )
-            pSimmNode2 = p->vSim1->pArray[ Abc_ObjFaninId1(pNode) ];
+            pSimmNode2 = (unsigned *)p->vSim1->pArray[ Abc_ObjFaninId1(pNode) ];
         else
-            pSimmNode2 = p->vSim0->pArray[ Abc_ObjFaninId1(pNode) ];
+            pSimmNode2 = (unsigned *)p->vSim0->pArray[ Abc_ObjFaninId1(pNode) ];
 
         fComp1 = Abc_ObjFaninC0(pNode);
         fComp2 = Abc_ObjFaninC1(pNode);
@@ -266,14 +269,14 @@ void Sim_UtilSimulateNode( Sim_Man_t * p, Abc_Obj_t * pNode, bool fType, bool fT
     {
         assert( Abc_ObjFaninNum(pNode) == 1 );
         if ( fType )
-            pSimmNode  = p->vSim1->pArray[ pNode->Id ];
+            pSimmNode  = (unsigned *)p->vSim1->pArray[ pNode->Id ];
         else
-            pSimmNode  = p->vSim0->pArray[ pNode->Id ];
+            pSimmNode  = (unsigned *)p->vSim0->pArray[ pNode->Id ];
 
         if ( fType1 )
-            pSimmNode1 = p->vSim1->pArray[ Abc_ObjFaninId0(pNode) ];
+            pSimmNode1 = (unsigned *)p->vSim1->pArray[ Abc_ObjFaninId0(pNode) ];
         else
-            pSimmNode1 = p->vSim0->pArray[ Abc_ObjFaninId0(pNode) ];
+            pSimmNode1 = (unsigned *)p->vSim0->pArray[ Abc_ObjFaninId0(pNode) ];
 
         fComp1 = Abc_ObjFaninC0(pNode);
         if ( fComp1 )
@@ -302,9 +305,9 @@ void Sim_UtilSimulateNodeOne( Abc_Obj_t * pNode, Vec_Ptr_t * vSimInfo, int nSimW
     int k, fComp1, fComp2;
     // simulate the internal nodes
     assert( Abc_ObjIsNode(pNode) );
-    pSimmNode  = Vec_PtrEntry(vSimInfo, pNode->Id);
-    pSimmNode1 = Vec_PtrEntry(vSimInfo, Abc_ObjFaninId0(pNode));
-    pSimmNode2 = Vec_PtrEntry(vSimInfo, Abc_ObjFaninId1(pNode));
+    pSimmNode  = (unsigned *)Vec_PtrEntry(vSimInfo, pNode->Id);
+    pSimmNode1 = (unsigned *)Vec_PtrEntry(vSimInfo, Abc_ObjFaninId0(pNode));
+    pSimmNode2 = (unsigned *)Vec_PtrEntry(vSimInfo, Abc_ObjFaninId1(pNode));
     pSimmNode  += nOffset;
     pSimmNode1 += nOffset;
     pSimmNode2 += nOffset;
@@ -341,8 +344,8 @@ void Sim_UtilTransferNodeOne( Abc_Obj_t * pNode, Vec_Ptr_t * vSimInfo, int nSimW
     int k, fComp1;
     // simulate the internal nodes
     assert( Abc_ObjIsCo(pNode) );
-    pSimmNode  = Vec_PtrEntry(vSimInfo, pNode->Id);
-    pSimmNode1 = Vec_PtrEntry(vSimInfo, Abc_ObjFaninId0(pNode));
+    pSimmNode  = (unsigned *)Vec_PtrEntry(vSimInfo, pNode->Id);
+    pSimmNode1 = (unsigned *)Vec_PtrEntry(vSimInfo, Abc_ObjFaninId0(pNode));
     pSimmNode  += nOffset + (fShift > 0)*nSimWords;
     pSimmNode1 += nOffset;
     fComp1 = Abc_ObjFaninC0(pNode);
@@ -425,7 +428,7 @@ Vec_Int_t * Sim_UtilCountOnesArray( Vec_Ptr_t * vInfo, int nSimWords )
     unsigned * pSimInfo;
     int i;
     vCounters = Vec_IntStart( Vec_PtrSize(vInfo) );
-    Vec_PtrForEachEntry( vInfo, pSimInfo, i )
+    Vec_PtrForEachEntry( unsigned *, vInfo, pSimInfo, i )
         Vec_IntWriteEntry( vCounters, i, Sim_UtilCountOnes(pSimInfo, nSimWords) );
     return vCounters;
 }
@@ -562,7 +565,7 @@ int Sim_UtilCountAllPairs( Vec_Ptr_t * vSuppFun, int nSimWords, Vec_Int_t * vCou
     unsigned * pSupp;
     int Counter, nOnes, nPairs, i;
     Counter = 0;
-    Vec_PtrForEachEntry( vSuppFun, pSupp, i )
+    Vec_PtrForEachEntry( unsigned *, vSuppFun, pSupp, i )
     {
         nOnes  = Sim_UtilCountOnes( pSupp, nSimWords );
         nPairs = nOnes * (nOnes - 1) / 2;
@@ -635,7 +638,7 @@ clk = clock();
     for ( i = 0; i < p->nOutputs; i++ )
     {
         printf( "Output %2d :", i );
-        Sim_UtilCountPairsOnePrint( Vec_PtrEntry(p->vMatrSymms, i), Vec_VecEntry(p->vSupports, i) );
+        Sim_UtilCountPairsOnePrint( (Extra_BitMat_t *)Vec_PtrEntry(p->vMatrSymms, i), (Vec_Int_t *)Vec_VecEntry(p->vSupports, i) );
         printf( "\n" );
     }
 p->timeCount += clock() - clk;
@@ -670,8 +673,8 @@ clk = clock();
             p->nPairsNonSymm += nPairsNonSym;
             continue;
         }
-        nPairsSym    = Sim_UtilCountPairsOne( Vec_PtrEntry(p->vMatrSymms,   i), Vec_VecEntry(p->vSupports, i) );
-        nPairsNonSym = Sim_UtilCountPairsOne( Vec_PtrEntry(p->vMatrNonSymms,i), Vec_VecEntry(p->vSupports, i) );
+        nPairsSym    = Sim_UtilCountPairsOne( (Extra_BitMat_t *)Vec_PtrEntry(p->vMatrSymms,   i), (Vec_Int_t *)Vec_VecEntry(p->vSupports, i) );
+        nPairsNonSym = Sim_UtilCountPairsOne( (Extra_BitMat_t *)Vec_PtrEntry(p->vMatrNonSymms,i), (Vec_Int_t *)Vec_VecEntry(p->vSupports, i) );
         assert( nPairsTotal >= nPairsSym + nPairsNonSym ); 
         Vec_IntWriteEntry( p->vPairsSym,    i, nPairsSym );
         Vec_IntWriteEntry( p->vPairsNonSym, i, nPairsNonSym );
@@ -699,7 +702,7 @@ int Sim_UtilMatrsAreDisjoint( Sym_Man_t * p )
 {
     int i;
     for ( i = 0; i < p->nOutputs; i++ )
-        if ( !Extra_BitMatrixIsDisjoint( Vec_PtrEntry(p->vMatrSymms,i), Vec_PtrEntry(p->vMatrNonSymms,i) ) )
+        if ( !Extra_BitMatrixIsDisjoint( (Extra_BitMat_t *)Vec_PtrEntry(p->vMatrSymms,i), (Extra_BitMat_t *)Vec_PtrEntry(p->vMatrNonSymms,i) ) )
             return 0;
     return 1;
 }
@@ -709,3 +712,5 @@ int Sim_UtilMatrsAreDisjoint( Sym_Man_t * p )
 ////////////////////////////////////////////////////////////////////////
 
 
+ABC_NAMESPACE_IMPL_END
+