Version abc80130_2

8 files changed, 100 insertions, 49 deletions

diff --git a/src/map/mio/mio.c b/src/map/mio/mio.c
index bb6dbba1..10a5af9d 100644
--- a/src/map/mio/mio.c
+++ b/src/map/mio/mio.c
@@ -55,7 +55,7 @@ static char * pMcncGenlib[25] = {
 };
 
 ////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFITIONS                           ///
+///                     FUNCTION DEFINITIONS                         ///
 ////////////////////////////////////////////////////////////////////////
 
 /**Function*************************************************************
@@ -108,7 +108,7 @@ void Mio_Init( Abc_Frame_t * pAbc )
 void Mio_End()
 {
 //    Mio_LibraryDelete( s_pLib );
-    Mio_LibraryDelete( Abc_FrameReadLibGen(Abc_FrameGetGlobalFrame()) );
+    Mio_LibraryDelete( Abc_FrameReadLibGen() );
 }
 
 
@@ -133,14 +133,14 @@ int Mio_CommandReadLibrary( Abc_Frame_t * pAbc, int argc, char **argv )
     int fVerbose;
     int c;
 
-    pNet = Abc_FrameReadNet(pAbc);
+    pNet = Abc_FrameReadNtk(pAbc);
     pOut = Abc_FrameReadOut(pAbc);
     pErr = Abc_FrameReadErr(pAbc);
 
     // set the defaults
     fVerbose = 1;
-    util_getopt_reset();
-    while ( (c = util_getopt(argc, argv, "vh")) != EOF ) 
+    Extra_UtilGetoptReset();
+    while ( (c = Extra_UtilGetopt(argc, argv, "vh")) != EOF ) 
     {
         switch (c) 
         {
@@ -156,14 +156,14 @@ int Mio_CommandReadLibrary( Abc_Frame_t * pAbc, int argc, char **argv )
     }
 
 
-    if ( argc != util_optind + 1 )
+    if ( argc != globalUtilOptind + 1 )
     {
         goto usage;
     }
 
     // get the input file name
-    FileName = argv[util_optind];
-    if ( (pFile = fopen( FileName, "r" )) == NULL )
+    FileName = argv[globalUtilOptind];
+    if ( (pFile = Io_FileOpen( FileName, "open_path", "r", 0 )) == NULL )
     {
         fprintf( pErr, "Cannot open input file \"%s\". ", FileName );
         if ( (FileName = Extra_FileGetSimilarName( FileName, ".genlib", ".lib", ".gen", ".g", NULL )) )
@@ -181,7 +181,7 @@ int Mio_CommandReadLibrary( Abc_Frame_t * pAbc, int argc, char **argv )
         return 1;
     }
     // free the current superlib because it depends on the old Mio library
-    if ( Abc_FrameReadLibSuper(Abc_FrameGetGlobalFrame()) )
+    if ( Abc_FrameReadLibSuper() )
     {
         extern void Map_SuperLibFree( Map_SuperLib_t * p );
 //        Map_SuperLibFree( s_pSuperLib );
@@ -223,14 +223,14 @@ int Mio_CommandPrintLibrary( Abc_Frame_t * pAbc, int argc, char **argv )
     int fVerbose;
     int c;
 
-    pNet = Abc_FrameReadNet(pAbc);
+    pNet = Abc_FrameReadNtk(pAbc);
     pOut = Abc_FrameReadOut(pAbc);
     pErr = Abc_FrameReadErr(pAbc);
 
     // set the defaults
     fVerbose = 1;
-    util_getopt_reset();
-    while ( (c = util_getopt(argc, argv, "vh")) != EOF ) 
+    Extra_UtilGetoptReset();
+    while ( (c = Extra_UtilGetopt(argc, argv, "vh")) != EOF ) 
     {
         switch (c) 
         {
@@ -246,13 +246,13 @@ int Mio_CommandPrintLibrary( Abc_Frame_t * pAbc, int argc, char **argv )
     }
 
 
-    if ( argc != util_optind )
+    if ( argc != globalUtilOptind )
     {
         goto usage;
     }
 
     // set the new network
-    Mio_WriteLibrary( stdout, Abc_FrameReadLibGen(Abc_FrameGetGlobalFrame()), 0 );
+    Mio_WriteLibrary( stdout, Abc_FrameReadLibGen(), 0 );
     return 0;
 
 usage:
diff --git a/src/map/mio/mio.h b/src/map/mio/mio.h
index f9f4973d..dbe2420b 100644
--- a/src/map/mio/mio.h
+++ b/src/map/mio/mio.h
@@ -19,6 +19,10 @@
 #ifndef __MIO_H__
 #define __MIO_H__
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 ////////////////////////////////////////////////////////////////////////
 ///                          INCLUDES                                ///
 ////////////////////////////////////////////////////////////////////////
@@ -42,7 +46,7 @@ typedef struct  Mio_PinStruct_t_          Mio_Pin_t;
 ////////////////////////////////////////////////////////////////////////
 
 ////////////////////////////////////////////////////////////////////////
-///                       MACRO DEFITIONS                            ///
+///                       MACRO DEFINITIONS                          ///
 ////////////////////////////////////////////////////////////////////////
  
 #define Mio_LibraryForEachGate( Lib, Gate )                   \
@@ -68,7 +72,7 @@ typedef struct  Mio_PinStruct_t_          Mio_Pin_t;
           Pin2 = (Pin? Mio_PinReadNext(Pin): NULL) )
 
 ////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFITIONS                           ///
+///                     FUNCTION DEFINITIONS                         ///
 ////////////////////////////////////////////////////////////////////////
 
 /*=== mioApi.c =============================================================*/
@@ -81,6 +85,7 @@ extern char *            Mio_LibraryReadSopByName  ( Mio_Library_t * pLib, char
 extern Mio_Gate_t *      Mio_LibraryReadConst0     ( Mio_Library_t * pLib );
 extern Mio_Gate_t *      Mio_LibraryReadConst1     ( Mio_Library_t * pLib );
 extern Mio_Gate_t *      Mio_LibraryReadNand2      ( Mio_Library_t * pLib );
+extern Mio_Gate_t *      Mio_LibraryReadAnd2       ( Mio_Library_t * pLib );
 extern Mio_Gate_t *      Mio_LibraryReadBuf        ( Mio_Library_t * pLib );
 extern Mio_Gate_t *      Mio_LibraryReadInv        ( Mio_Library_t * pLib );
 extern float             Mio_LibraryReadDelayInvRise( Mio_Library_t * pLib );
@@ -89,9 +94,11 @@ extern float             Mio_LibraryReadDelayInvMax( Mio_Library_t * pLib );
 extern float             Mio_LibraryReadDelayNand2Rise( Mio_Library_t * pLib );
 extern float             Mio_LibraryReadDelayNand2Fall( Mio_Library_t * pLib );
 extern float             Mio_LibraryReadDelayNand2Max( Mio_Library_t * pLib );
+extern float             Mio_LibraryReadDelayAnd2Max( Mio_Library_t * pLib );
 extern float             Mio_LibraryReadAreaInv    ( Mio_Library_t * pLib );
 extern float             Mio_LibraryReadAreaBuf    ( Mio_Library_t * pLib );
 extern float             Mio_LibraryReadAreaNand2  ( Mio_Library_t * pLib );
+extern int               Mio_LibraryReadGateNameMax( Mio_Library_t * pLib );
 extern char *            Mio_GateReadName          ( Mio_Gate_t * pGate );      
 extern char *            Mio_GateReadOutName       ( Mio_Gate_t * pGate );      
 extern double            Mio_GateReadArea          ( Mio_Gate_t * pGate );      
@@ -114,8 +121,8 @@ extern double            Mio_PinReadDelayFanoutFall( Mio_Pin_t * pPin );
 extern double            Mio_PinReadDelayBlockMax  ( Mio_Pin_t * pPin );  
 extern Mio_Pin_t *       Mio_PinReadNext           ( Mio_Pin_t * pPin );  
 /*=== mioRead.c =============================================================*/
-extern Mio_Library_t *   Mio_LibraryRead( Abc_Frame_t * pAbc, char * FileName, char * ExcludeFile, int fVerbose );
-extern int               Mio_LibraryReadExclude( Abc_Frame_t * pAbc, char * ExcludeFile, st_table * tExcludeGate );
+extern Mio_Library_t *   Mio_LibraryRead( void * pAbc, char * FileName, char * ExcludeFile, int fVerbose );
+extern int               Mio_LibraryReadExclude( void * pAbc, char * ExcludeFile, st_table * tExcludeGate );
 /*=== mioFunc.c =============================================================*/
 extern int               Mio_LibraryParseFormulas( Mio_Library_t * pLib );
 /*=== mioUtils.c =============================================================*/
@@ -131,7 +138,13 @@ extern void              Mio_DeriveGateDelays( Mio_Gate_t * pGate,
                             float * ptDelaysRes, float * ptPinDelayMax );
 extern Mio_Gate_t *      Mio_GateCreatePseudo( int nInputs );
 
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
 ////////////////////////////////////////////////////////////////////////
 ///                       END OF FILE                                ///
 ////////////////////////////////////////////////////////////////////////
-#endif
+
diff --git a/src/map/mio/mioApi.c b/src/map/mio/mioApi.c
index a39c6288..73473f8b 100644
--- a/src/map/mio/mioApi.c
+++ b/src/map/mio/mioApi.c
@@ -23,7 +23,7 @@
 ////////////////////////////////////////////////////////////////////////
 
 ////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFITIONS                           ///
+///                     FUNCTION DEFINITIONS                         ///
 ////////////////////////////////////////////////////////////////////////
 
 /**Function*************************************************************
@@ -43,21 +43,47 @@ Mio_Gate_t *      Mio_LibraryReadGates         ( Mio_Library_t * pLib )  { retur
 DdManager *       Mio_LibraryReadDd            ( Mio_Library_t * pLib )  { return pLib->dd;       }
 Mio_Gate_t *      Mio_LibraryReadBuf           ( Mio_Library_t * pLib )  { return pLib->pGateBuf; }
 Mio_Gate_t *      Mio_LibraryReadInv           ( Mio_Library_t * pLib )  { return pLib->pGateInv; }
-Mio_Gate_t *      Mio_LibraryReadConst0        ( Mio_Library_t * pLib )  { return pLib->pGate0; }
-Mio_Gate_t *      Mio_LibraryReadConst1        ( Mio_Library_t * pLib )  { return pLib->pGate1; }
+Mio_Gate_t *      Mio_LibraryReadConst0        ( Mio_Library_t * pLib )  { return pLib->pGate0;     }
+Mio_Gate_t *      Mio_LibraryReadConst1        ( Mio_Library_t * pLib )  { return pLib->pGate1;     }
 Mio_Gate_t *      Mio_LibraryReadNand2         ( Mio_Library_t * pLib )  { return pLib->pGateNand2; }
+Mio_Gate_t *      Mio_LibraryReadAnd2          ( Mio_Library_t * pLib )  { return pLib->pGateAnd2;  }
 float             Mio_LibraryReadDelayInvRise  ( Mio_Library_t * pLib )  { return (float)(pLib->pGateInv?   pLib->pGateInv->pPins->dDelayBlockRise   : 0.0); }
 float             Mio_LibraryReadDelayInvFall  ( Mio_Library_t * pLib )  { return (float)(pLib->pGateInv?   pLib->pGateInv->pPins->dDelayBlockFall   : 0.0); }
 float             Mio_LibraryReadDelayInvMax   ( Mio_Library_t * pLib )  { return (float)(pLib->pGateInv?   pLib->pGateInv->pPins->dDelayBlockMax    : 0.0); }
 float             Mio_LibraryReadDelayNand2Rise( Mio_Library_t * pLib )  { return (float)(pLib->pGateNand2? pLib->pGateNand2->pPins->dDelayBlockRise : 0.0); }
 float             Mio_LibraryReadDelayNand2Fall( Mio_Library_t * pLib )  { return (float)(pLib->pGateNand2? pLib->pGateNand2->pPins->dDelayBlockFall : 0.0); }
 float             Mio_LibraryReadDelayNand2Max ( Mio_Library_t * pLib )  { return (float)(pLib->pGateNand2? pLib->pGateNand2->pPins->dDelayBlockMax  : 0.0); }
+float             Mio_LibraryReadDelayAnd2Max  ( Mio_Library_t * pLib )  { return (float)(pLib->pGateAnd2?  pLib->pGateAnd2->pPins->dDelayBlockMax   : 0.0); }
 float             Mio_LibraryReadAreaInv       ( Mio_Library_t * pLib )  { return (float)(pLib->pGateInv?   pLib->pGateInv->dArea   : 0.0); }
 float             Mio_LibraryReadAreaBuf       ( Mio_Library_t * pLib )  { return (float)(pLib->pGateBuf?   pLib->pGateBuf->dArea   : 0.0); }
 float             Mio_LibraryReadAreaNand2     ( Mio_Library_t * pLib )  { return (float)(pLib->pGateNand2? pLib->pGateNand2->dArea : 0.0); }
 
 /**Function*************************************************************
 
+  Synopsis    [Returns the longest gate name.]
+
+  Description []
+               
+  SideEffects []
+
+  SeeAlso     []
+
+***********************************************************************/
+int Mio_LibraryReadGateNameMax( Mio_Library_t * pLib )
+{
+    Mio_Gate_t * pGate;
+    int LenMax = 0, LenCur;
+    Mio_LibraryForEachGate( pLib, pGate )
+    {
+        LenCur = strlen( Mio_GateReadName(pGate) );
+        if ( LenMax < LenCur )
+            LenMax = LenCur;
+    }
+    return LenMax;
+}
+
+/**Function*************************************************************
+
   Synopsis    [Read Mvc of the gate by name.]
 
   Description []
diff --git a/src/map/mio/mioFunc.c b/src/map/mio/mioFunc.c
index 24b2fecb..21a078f9 100644
--- a/src/map/mio/mioFunc.c
+++ b/src/map/mio/mioFunc.c
@@ -35,7 +35,7 @@ static int Mio_GateParseFormula( Mio_Gate_t * pGate );
 static int Mio_GateCollectNames( char * pFormula, char * pPinNames[] );
 
 ////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFITIONS                           ///
+///                     FUNCTION DEFINITIONS                         ///
 ////////////////////////////////////////////////////////////////////////
 
 /**Function*************************************************************
@@ -213,7 +213,7 @@ int Mio_GateParseFormula( Mio_Gate_t * pGate )
     Cudd_Ref( pGate->bFunc );
 
     // derive the cover (SOP)
-    pGate->pSop = Abc_ConvertBddToSop( pGate->pLib->pMmFlex, dd, pGate->bFunc, pGate->bFunc, nPins, pGate->pLib->vCube, -1 );
+    pGate->pSop = Abc_ConvertBddToSop( pGate->pLib->pMmFlex, dd, pGate->bFunc, pGate->bFunc, nPins, 0, pGate->pLib->vCube, -1 );
     return 0;
 }
 
@@ -253,7 +253,7 @@ int Mio_GateCollectNames( char * pFormula, char * pPinNames[] )
                 break;
         if ( i == nPins )
         { // cannot find this name; save it
-            pPinNames[nPins++] = util_strsav(pTemp);
+            pPinNames[nPins++] = Extra_UtilStrsav(pTemp);
         }
         // get the next name
         pTemp = strtok( NULL, " " );
diff --git a/src/map/mio/mioGENERIC.c b/src/map/mio/mioGENERIC.c
index 6a40bc52..972c4ffc 100644
--- a/src/map/mio/mioGENERIC.c
+++ b/src/map/mio/mioGENERIC.c
@@ -23,7 +23,7 @@
 ////////////////////////////////////////////////////////////////////////
 
 ////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFITIONS                           ///
+///                     FUNCTION DEFINITIONS                         ///
 ////////////////////////////////////////////////////////////////////////
 
 /**Function*************************************************************
diff --git a/src/map/mio/mioInt.h b/src/map/mio/mioInt.h
index 105e3d8d..3f90b625 100644
--- a/src/map/mio/mioInt.h
+++ b/src/map/mio/mioInt.h
@@ -60,6 +60,7 @@ struct  Mio_LibraryStruct_t_
     Mio_Gate_t *       pGateBuf;    // the buffer
     Mio_Gate_t *       pGateInv;    // the inverter
     Mio_Gate_t *       pGateNand2;  // the NAND2 gate
+    Mio_Gate_t *       pGateAnd2;   // the AND2 gate
     st_table *         tName2Gate;  // the mapping of gate names into their pointer
     DdManager *        dd;          // the nanager storing functions of gates
     Extra_MmFlex_t *   pMmFlex;     // the memory manaqer for SOPs
@@ -106,19 +107,19 @@ struct  Mio_PinStruct_t_
 ////////////////////////////////////////////////////////////////////////
 
 ////////////////////////////////////////////////////////////////////////
-///                       MACRO DEFITIONS                            ///
+///                       MACRO DEFINITIONS                          ///
 ////////////////////////////////////////////////////////////////////////
 
 ////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFITIONS                           ///
+///                     FUNCTION DEFINITIONS                         ///
 ////////////////////////////////////////////////////////////////////////
 
 /*=== mio.c =============================================================*/
 /*=== mioRead.c =============================================================*/
 /*=== mioUtils.c =============================================================*/
 
+#endif
+
 ////////////////////////////////////////////////////////////////////////
 ///                       END OF FILE                                ///
 ////////////////////////////////////////////////////////////////////////
-
-#endif
diff --git a/src/map/mio/mioRead.c b/src/map/mio/mioRead.c
index f2778ca4..13c2cdcd 100644
--- a/src/map/mio/mioRead.c
+++ b/src/map/mio/mioRead.c
@@ -23,7 +23,7 @@
 ////////////////////////////////////////////////////////////////////////
 
 ////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFITIONS                           ///
+///                     FUNCTION DEFINITIONS                         ///
 ////////////////////////////////////////////////////////////////////////
 
 static Mio_Library_t * Mio_LibraryReadOne( Abc_Frame_t * pAbc, char * FileName, bool fExtendedFormat, st_table * tExcludeGate, int fVerbose );
@@ -49,7 +49,7 @@ extern int          isspace( int c );  // to silence the warning in VS
   SeeAlso     []
 
 ***********************************************************************/
-Mio_Library_t * Mio_LibraryRead( Abc_Frame_t * pAbc, char * FileName, char * ExcludeFile, int fVerbose )
+Mio_Library_t * Mio_LibraryRead( void * pAbc, char * FileName, char * ExcludeFile, int fVerbose )
 {
     Mio_Library_t * pLib;
     int num;
@@ -99,7 +99,7 @@ Mio_Library_t * Mio_LibraryReadOne( Abc_Frame_t * pAbc, char * FileName, bool fE
     // allocate the genlib structure
     pLib = ALLOC( Mio_Library_t, 1 );
     memset( pLib, 0, sizeof(Mio_Library_t) );
-    pLib->pName = util_strsav( FileName );
+    pLib->pName = Extra_UtilStrsav( FileName );
     pLib->tName2Gate = st_init_table(strcmp, st_strhash);
     pLib->pMmFlex = Extra_MmFlexStart();
     pLib->vCube = Vec_StrAlloc( 100 );
@@ -114,8 +114,8 @@ Mio_Library_t * Mio_LibraryReadOne( Abc_Frame_t * pAbc, char * FileName, bool fE
         int nFileSize;
 
         // open the BLIF file for binary reading
-//        pFile = Io_FileOpen( FileName, "open_path", "rb" );
-        pFile = fopen( FileName, "rb" );
+        pFile = Io_FileOpen( FileName, "open_path", "rb", 1 );
+//        pFile = fopen( FileName, "rb" );
         // if we got this far, file should be okay otherwise would
         // have been detected by caller
         assert ( pFile != NULL );
@@ -251,7 +251,7 @@ Mio_Gate_t * Mio_LibraryReadGate( char ** ppToken, bool fExtendedFormat )
 
     // read the name
     pToken = strtok( NULL, " \t\r\n" );
-    pGate->pName = util_strsav( pToken );
+    pGate->pName = Extra_UtilStrsav( pToken );
 
     // read the area
     pToken = strtok( NULL, " \t\r\n" );
@@ -265,7 +265,7 @@ Mio_Gate_t * Mio_LibraryReadGate( char ** ppToken, bool fExtendedFormat )
 
     // then rest of the expression 
     pToken = strtok( NULL, ";" );
-    pGate->pForm = util_strsav( pToken );
+    pGate->pForm = Extra_UtilStrsav( pToken );
 
     // read the pin info
     // start the linked list of pins
@@ -319,7 +319,7 @@ Mio_Pin_t * Mio_LibraryReadPin( char ** ppToken, bool fExtendedFormat )
 
     // read the name
     pToken = strtok( NULL, " \t\r\n" );
-    pPin->pName = util_strsav( pToken );
+    pPin->pName = Extra_UtilStrsav( pToken );
 
     // read the pin phase
     pToken = strtok( NULL, " \t\r\n" );
@@ -418,12 +418,14 @@ char *chomp( char *s )
 void Mio_LibraryDetectSpecialGates( Mio_Library_t * pLib )
 {
     Mio_Gate_t * pGate;
-    DdNode * bFuncBuf, * bFuncInv, * bFuncNand2;
+    DdNode * bFuncBuf, * bFuncInv, * bFuncNand2, * bFuncAnd2;
 
     bFuncBuf   = pLib->dd->vars[0];                                              Cudd_Ref( bFuncBuf );
     bFuncInv   = Cudd_Not( pLib->dd->vars[0] );                                  Cudd_Ref( bFuncInv );
     bFuncNand2 = Cudd_bddNand( pLib->dd, pLib->dd->vars[0], pLib->dd->vars[1] ); Cudd_Ref( bFuncNand2 );
+    bFuncAnd2  = Cudd_bddAnd( pLib->dd, pLib->dd->vars[0], pLib->dd->vars[1] );  Cudd_Ref( bFuncAnd2 );
 
+    // get buffer
     Mio_LibraryForEachGate( pLib, pGate )
         if ( pLib->pGateBuf == NULL && pGate->bFunc == bFuncBuf )
         {
@@ -435,7 +437,8 @@ void Mio_LibraryDetectSpecialGates( Mio_Library_t * pLib )
         printf( "Warnings: GENLIB library reader cannot detect the buffer gate.\n" );
         printf( "Some parts of the supergate-based technology mapper may not work correctly.\n" );
     }
-
+ 
+    // get inverter
     Mio_LibraryForEachGate( pLib, pGate )
         if ( pLib->pGateInv == NULL && pGate->bFunc == bFuncInv )
         {
@@ -448,20 +451,28 @@ void Mio_LibraryDetectSpecialGates( Mio_Library_t * pLib )
         printf( "Some parts of the supergate-based technology mapper may not work correctly.\n" );
     }
 
+    // get the NAND2 and AND2 gates
     Mio_LibraryForEachGate( pLib, pGate )
         if ( pLib->pGateNand2 == NULL && pGate->bFunc == bFuncNand2 )
         {
             pLib->pGateNand2 = pGate;
             break;
         }
-    if ( pLib->pGateNand2 == NULL )
+    Mio_LibraryForEachGate( pLib, pGate )
+        if ( pLib->pGateAnd2 == NULL && pGate->bFunc == bFuncAnd2 )
+        {
+            pLib->pGateAnd2 = pGate;
+            break;
+        }
+    if ( pLib->pGateAnd2 == NULL && pLib->pGateNand2 == NULL )
     {
-        printf( "Warnings: GENLIB library reader cannot detect the NAND2 gate.\n" );
+        printf( "Warnings: GENLIB library reader cannot detect the AND2 or NAND2 gate.\n" );
         printf( "Some parts of the supergate-based technology mapper may not work correctly.\n" );
     }
 
     Cudd_RecursiveDeref( pLib->dd, bFuncInv );
     Cudd_RecursiveDeref( pLib->dd, bFuncNand2 );
+    Cudd_RecursiveDeref( pLib->dd, bFuncAnd2 );
 }
 
 /**Function*************************************************************
@@ -475,7 +486,7 @@ void Mio_LibraryDetectSpecialGates( Mio_Library_t * pLib )
   SeeAlso     []
 
 ***********************************************************************/
-int Mio_LibraryReadExclude( Abc_Frame_t * pAbc, char * ExcludeFile, st_table * tExcludeGate )
+int Mio_LibraryReadExclude( void * pAbc, char * ExcludeFile, st_table * tExcludeGate )
 {
     int nDel = 0;
     FILE *pEx;
@@ -496,7 +507,7 @@ int Mio_LibraryReadExclude( Abc_Frame_t * pAbc, char * ExcludeFile, st_table * t
         while (1 == fscanf( pEx, "%127s", buffer ))
         {
             //printf ("Read: '%s'\n", buffer );
-            st_insert( tExcludeGate, util_strsav( buffer ), (char *)0 );
+            st_insert( tExcludeGate, Extra_UtilStrsav( buffer ), (char *)0 );
             nDel++;
         }
 
diff --git a/src/map/mio/mioUtils.c b/src/map/mio/mioUtils.c
index 15f32890..bd3d01f7 100644
--- a/src/map/mio/mioUtils.c
+++ b/src/map/mio/mioUtils.c
@@ -28,7 +28,7 @@ static int  Mio_DelayCompare( Mio_Gate_t ** ppG1, Mio_Gate_t ** ppG2 );
 static void Mio_DeriveTruthTable_rec( DdNode * bFunc, unsigned uTruthsIn[][2], unsigned uTruthRes[] );
 
 ////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFITIONS                           ///
+///                     FUNCTION DEFINITIONS                         ///
 ////////////////////////////////////////////////////////////////////////
 
 /**Function*************************************************************
@@ -53,7 +53,7 @@ void Mio_LibraryDelete( Mio_Library_t * pLib )
     FREE( pLib->pName );
     Mio_LibraryForEachGateSafe( pLib, pGate, pGate2 )
         Mio_GateDelete( pGate );
-    Extra_MmFlexStop( pLib->pMmFlex, 0 );
+    Extra_MmFlexStop( pLib->pMmFlex );
     Vec_StrFree( pLib->vCube );
     if ( pLib->tName2Gate )
         st_free_table( pLib->tName2Gate );
@@ -120,7 +120,7 @@ Mio_Pin_t * Mio_PinDup( Mio_Pin_t * pPin )
 
     pPinNew = ALLOC( Mio_Pin_t, 1 );
     *pPinNew = *pPin;
-    pPinNew->pName = (pPinNew->pName ? util_strsav(pPinNew->pName) : NULL);
+    pPinNew->pName = (pPinNew->pName ? Extra_UtilStrsav(pPinNew->pName) : NULL);
     pPinNew->pNext = NULL;
 
     return pPinNew;
@@ -165,9 +165,9 @@ void Mio_WriteGate( FILE * pFile, Mio_Gate_t * pGate, int fPrintSops )
     Mio_Pin_t * pPin;
 
     fprintf( pFile, "GATE " );
-    fprintf( pFile, "%12s ",   pGate->pName );
+    fprintf( pFile, "%12s ",      pGate->pName );
     fprintf( pFile, "%10.2f   ",  pGate->dArea );
-    fprintf( pFile, "O=%s;\n",    pGate->pForm );
+    fprintf( pFile, "%s=%s;\n",   pGate->pOutName,    pGate->pForm );
     // print the pins
     if ( fPrintSops )
         fprintf( pFile, "%s",       pGate->pSop? pGate->pSop : "unspecified\n" );