Version abc70930

9 files changed, 0 insertions, 2148 deletions

diff --git a/src/map/mio/mio.c b/src/map/mio/mio.c
deleted file mode 100644
index 10a5af9d..00000000
--- a/src/map/mio/mio.c
+++ /dev/null
@@ -1,269 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [mio.c]
-
-  PackageName [MVSIS 1.3: Multi-valued logic synthesis system.]
-
-  Synopsis    [File reading/writing for technology mapping.]
-
-  Author      [MVSIS Group]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - August 18, 2003.]
-
-  Revision    [$Id: mio.c,v 1.4 2004/08/05 18:34:51 satrajit Exp $]
-
-***********************************************************************/
-
-#include "abc.h"
-#include "mvc.h"
-#include "mainInt.h"
-#include "mioInt.h"
-#include "mapper.h"
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-static int Mio_CommandReadLibrary( Abc_Frame_t * pAbc, int argc, char **argv );
-static int Mio_CommandPrintLibrary( Abc_Frame_t * pAbc, int argc, char **argv );
-
-// internal version of GENLIB library
-static char * pMcncGenlib[25] = {
-    "GATE inv1    1   O=!a;             PIN * INV     1 999 0.9 0.0 0.9 0.0\n",
-    "GATE inv2    2   O=!a;             PIN * INV     2 999 1.0 0.0 1.0 0.0\n",
-    "GATE inv3    3   O=!a;             PIN * INV     3 999 1.1 0.0 1.1 0.0\n",
-    "GATE inv4    4   O=!a;             PIN * INV     4 999 1.2 0.0 1.2 0.0\n",
-    "GATE nand2   2   O=!(a*b);         PIN * INV     1 999 1.0 0.0 1.0 0.0\n",
-    "GATE nand3   3   O=!(a*b*c);       PIN * INV     1 999 1.1 0.0 1.1 0.0\n",
-    "GATE nand4   4   O=!(a*b*c*d);     PIN * INV     1 999 1.4 0.0 1.4 0.0\n",
-    "GATE nor2    2   O=!(a+b);         PIN * INV     1 999 1.4 0.0 1.4 0.0\n",
-    "GATE nor3    3   O=!(a+b+c);       PIN * INV     1 999 2.4 0.0 2.4 0.0\n",
-    "GATE nor4    4   O=!(a+b+c+d);     PIN * INV     1 999 3.8 0.0 3.8 0.0\n",
-    "GATE xora    5   O=a*!b+!a*b;      PIN * UNKNOWN 2 999 1.9 0.0 1.9 0.0\n",
-    "GATE xorb    5   O=!(a*b+!a*!b);   PIN * UNKNOWN 2 999 1.9 0.0 1.9 0.0\n",
-    "GATE xnora   5   O=a*b+!a*!b;      PIN * UNKNOWN 2 999 2.1 0.0 2.1 0.0\n",
-    "GATE xnorb   5   O=!(!a*b+a*!b);   PIN * UNKNOWN 2 999 2.1 0.0 2.1 0.0\n",
-    "GATE aoi21   3   O=!(a*b+c);       PIN * INV     1 999 1.6 0.0 1.6 0.0\n",
-    "GATE aoi22   4   O=!(a*b+c*d);     PIN * INV     1 999 2.0 0.0 2.0 0.0\n",
-    "GATE oai21   3   O=!((a+b)*c);     PIN * INV     1 999 1.6 0.0 1.6 0.0\n",
-    "GATE oai22   4   O=!((a+b)*(c+d)); PIN * INV     1 999 2.0 0.0 2.0 0.0\n",
-    "GATE buf     1   O=a;              PIN * NONINV  1 999 1.0 0.0 1.0 0.0\n",
-    "GATE zero    0   O=CONST0;\n",
-    "GATE one     0   O=CONST1;\n"
-};
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Mio_Init( Abc_Frame_t * pAbc )
-{
-    char * pFileTemp = "mcnc_temp.genlib";
-    Mio_Library_t * pLibGen;
-    FILE * pFile;
-    int i;
-
-    // write genlib into file
-    pFile = fopen( pFileTemp, "w" );
-    for ( i = 0; pMcncGenlib[i]; i++ )
-        fputs( pMcncGenlib[i], pFile );
-    fclose( pFile );
-    // read genlib from file
-    pLibGen = Mio_LibraryRead( pAbc, pFileTemp, NULL, 0 );
-    Abc_FrameSetLibGen( pLibGen );
-#ifdef WIN32
-        _unlink( pFileTemp );
-#else
-        unlink( pFileTemp );
-#endif
-
-    Cmd_CommandAdd( pAbc, "SC mapping", "read_library",   Mio_CommandReadLibrary,  0 ); 
-    Cmd_CommandAdd( pAbc, "SC mapping", "print_library",  Mio_CommandPrintLibrary, 0 ); 
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Mio_End()
-{
-//    Mio_LibraryDelete( s_pLib );
-    Mio_LibraryDelete( Abc_FrameReadLibGen() );
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Mio_CommandReadLibrary( Abc_Frame_t * pAbc, int argc, char **argv )
-{
-    FILE * pFile;
-    FILE * pOut, * pErr;
-    Mio_Library_t * pLib;
-    Abc_Ntk_t * pNet;
-    char * FileName;
-    int fVerbose;
-    int c;
-
-    pNet = Abc_FrameReadNtk(pAbc);
-    pOut = Abc_FrameReadOut(pAbc);
-    pErr = Abc_FrameReadErr(pAbc);
-
-    // set the defaults
-    fVerbose = 1;
-    Extra_UtilGetoptReset();
-    while ( (c = Extra_UtilGetopt(argc, argv, "vh")) != EOF ) 
-    {
-        switch (c) 
-        {
-            case 'v':
-                fVerbose ^= 1;
-                break;
-            case 'h':
-                goto usage;
-                break;
-            default:
-                goto usage;
-        }
-    }
-
-
-    if ( argc != globalUtilOptind + 1 )
-    {
-        goto usage;
-    }
-
-    // get the input file name
-    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 )) )
-            fprintf( pErr, "Did you mean \"%s\"?", FileName );
-        fprintf( pErr, "\n" );
-        return 1;
-    }
-    fclose( pFile );
-
-    // set the new network
-    pLib = Mio_LibraryRead( pAbc, FileName, 0, fVerbose );  
-    if ( pLib == NULL )
-    {
-        fprintf( pErr, "Reading GENLIB library has failed.\n" );
-        return 1;
-    }
-    // free the current superlib because it depends on the old Mio library
-    if ( Abc_FrameReadLibSuper() )
-    {
-        extern void Map_SuperLibFree( Map_SuperLib_t * p );
-//        Map_SuperLibFree( s_pSuperLib );
-//        s_pSuperLib = NULL;
-        Map_SuperLibFree( Abc_FrameReadLibSuper() );
-        Abc_FrameSetLibSuper( NULL );
-    }
-
-    // replace the current library
-//    Mio_LibraryDelete( s_pLib );
-//    s_pLib = pLib;
-    Mio_LibraryDelete( Abc_FrameReadLibGen() );
-    Abc_FrameSetLibGen( pLib );
-    return 0;
-
-usage:
-    fprintf( pErr, "usage: read_library [-vh]\n");
-    fprintf( pErr, "\t         read the library from a genlib file\n" );  
-    fprintf( pErr, "\t-h     : enable verbose output\n");
-    return 1;       /* error exit */
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Command procedure to read LUT libraries.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Mio_CommandPrintLibrary( Abc_Frame_t * pAbc, int argc, char **argv )
-{
-    FILE * pOut, * pErr;
-    Abc_Ntk_t * pNet;
-    int fVerbose;
-    int c;
-
-    pNet = Abc_FrameReadNtk(pAbc);
-    pOut = Abc_FrameReadOut(pAbc);
-    pErr = Abc_FrameReadErr(pAbc);
-
-    // set the defaults
-    fVerbose = 1;
-    Extra_UtilGetoptReset();
-    while ( (c = Extra_UtilGetopt(argc, argv, "vh")) != EOF ) 
-    {
-        switch (c) 
-        {
-            case 'v':
-                fVerbose ^= 1;
-                break;
-            case 'h':
-                goto usage;
-                break;
-            default:
-                goto usage;
-        }
-    }
-
-
-    if ( argc != globalUtilOptind )
-    {
-        goto usage;
-    }
-
-    // set the new network
-    Mio_WriteLibrary( stdout, Abc_FrameReadLibGen(), 0 );
-    return 0;
-
-usage:
-    fprintf( pErr, "\nusage: print_library [-vh]\n");
-    fprintf( pErr, "\t          print the current genlib library\n" );  
-    fprintf( pErr, "\t-v      : toggles enabling of verbose output [default = %s]\n", (fVerbose? "yes" : "no") );
-    fprintf( pErr, "\t-h      : print the command usage\n");
-    return 1;       /* error exit */
-}
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
diff --git a/src/map/mio/mio.h b/src/map/mio/mio.h
deleted file mode 100644
index dbe2420b..00000000
--- a/src/map/mio/mio.h
+++ /dev/null
@@ -1,150 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [mio.h]
-
-  PackageName [MVSIS 2.0: Multi-valued logic synthesis system.]
-
-  Synopsis    [File reading/writing for technology mapping.]
-
-  Author      [MVSIS Group]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - September 8, 2003.]
-
-  Revision    [$Id: mio.h,v 1.6 2004/08/09 22:16:31 satrajit Exp $]
-
-***********************************************************************/
-
-#ifndef __MIO_H__
-#define __MIO_H__
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-////////////////////////////////////////////////////////////////////////
-///                          INCLUDES                                ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                         PARAMETERS                               ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                    STRUCTURE DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-typedef enum { MIO_PHASE_UNKNOWN, MIO_PHASE_INV, MIO_PHASE_NONINV } Mio_PinPhase_t;
-
-typedef struct  Mio_LibraryStruct_t_      Mio_Library_t;
-typedef struct  Mio_GateStruct_t_         Mio_Gate_t;
-typedef struct  Mio_PinStruct_t_          Mio_Pin_t;
-
-////////////////////////////////////////////////////////////////////////
-///                       GLOBAL VARIABLES                           ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                       MACRO DEFINITIONS                          ///
-////////////////////////////////////////////////////////////////////////
- 
-#define Mio_LibraryForEachGate( Lib, Gate )                   \
-    for ( Gate = Mio_LibraryReadGates(Lib);                   \
-          Gate;                                               \
-          Gate = Mio_GateReadNext(Gate) )
-#define Mio_LibraryForEachGateSafe( Lib, Gate, Gate2 )        \
-    for ( Gate = Mio_LibraryReadGates(Lib),                   \
-          Gate2 = (Gate? Mio_GateReadNext(Gate): NULL);       \
-          Gate;                                               \
-          Gate = Gate2,                                       \
-          Gate2 = (Gate? Mio_GateReadNext(Gate): NULL) )
-
-#define Mio_GateForEachPin( Gate, Pin )                       \
-    for ( Pin = Mio_GateReadPins(Gate);                       \
-          Pin;                                                \
-          Pin = Mio_PinReadNext(Pin) )
-#define Mio_GateForEachPinSafe( Gate, Pin, Pin2 )              \
-    for ( Pin = Mio_GateReadPins(Gate),                        \
-          Pin2 = (Pin? Mio_PinReadNext(Pin): NULL);           \
-          Pin;                                                \
-          Pin = Pin2,                                         \
-          Pin2 = (Pin? Mio_PinReadNext(Pin): NULL) )
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/*=== mioApi.c =============================================================*/
-extern char *            Mio_LibraryReadName       ( Mio_Library_t * pLib );
-extern int               Mio_LibraryReadGateNum    ( Mio_Library_t * pLib );
-extern Mio_Gate_t *      Mio_LibraryReadGates      ( Mio_Library_t * pLib );
-extern DdManager *       Mio_LibraryReadDd         ( Mio_Library_t * pLib );
-extern Mio_Gate_t *      Mio_LibraryReadGateByName ( Mio_Library_t * pLib, char * pName );
-extern char *            Mio_LibraryReadSopByName  ( Mio_Library_t * pLib, char * pName );    
-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 );
-extern float             Mio_LibraryReadDelayInvFall( Mio_Library_t * pLib );
-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 );      
-extern char *            Mio_GateReadForm          ( Mio_Gate_t * pGate );      
-extern Mio_Pin_t *       Mio_GateReadPins          ( Mio_Gate_t * pGate );      
-extern Mio_Library_t *   Mio_GateReadLib           ( Mio_Gate_t * pGate );      
-extern Mio_Gate_t *      Mio_GateReadNext          ( Mio_Gate_t * pGate );      
-extern int               Mio_GateReadInputs        ( Mio_Gate_t * pGate );      
-extern double            Mio_GateReadDelayMax      ( Mio_Gate_t * pGate );      
-extern char *            Mio_GateReadSop           ( Mio_Gate_t * pGate );      
-extern DdNode *          Mio_GateReadFunc          ( Mio_Gate_t * pGate );
-extern char *            Mio_PinReadName           ( Mio_Pin_t * pPin );  
-extern Mio_PinPhase_t    Mio_PinReadPhase          ( Mio_Pin_t * pPin );  
-extern double            Mio_PinReadInputLoad      ( Mio_Pin_t * pPin );  
-extern double            Mio_PinReadMaxLoad        ( Mio_Pin_t * pPin );  
-extern double            Mio_PinReadDelayBlockRise ( Mio_Pin_t * pPin );  
-extern double            Mio_PinReadDelayFanoutRise( Mio_Pin_t * pPin );  
-extern double            Mio_PinReadDelayBlockFall ( Mio_Pin_t * pPin );  
-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( 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 =============================================================*/
-extern void              Mio_LibraryDelete( Mio_Library_t * pLib );
-extern void              Mio_GateDelete( Mio_Gate_t * pGate );
-extern void              Mio_PinDelete( Mio_Pin_t * pPin );
-extern Mio_Pin_t *       Mio_PinDup( Mio_Pin_t * pPin );
-extern void              Mio_WriteLibrary( FILE * pFile, Mio_Library_t * pLib, int fPrintSops );
-extern Mio_Gate_t **     Mio_CollectRoots( Mio_Library_t * pLib, int nInputs, float tDelay, bool fSkipInv, int * pnGates );
-extern void              Mio_DeriveTruthTable( Mio_Gate_t * pGate, unsigned uTruthsIn[][2], int nSigns, int nInputs, unsigned uTruthRes[] );
-extern void              Mio_DeriveGateDelays( Mio_Gate_t * pGate, 
-                            float ** ptPinDelays, int nPins, int nInputs, float tDelayZero, 
-                            float * ptDelaysRes, float * ptPinDelayMax );
-extern Mio_Gate_t *      Mio_GateCreatePseudo( int nInputs );
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
diff --git a/src/map/mio/mioApi.c b/src/map/mio/mioApi.c
deleted file mode 100644
index 73473f8b..00000000
--- a/src/map/mio/mioApi.c
+++ /dev/null
@@ -1,172 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [mioApi.c]
-
-  PackageName [MVSIS 1.3: Multi-valued logic synthesis system.]
-
-  Synopsis    [File reading/writing for technology mapping.]
-
-  Author      [MVSIS Group]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - September 8, 2003.]
-
-  Revision    [$Id: mioApi.c,v 1.4 2004/06/28 14:20:25 alanmi Exp $]
-
-***********************************************************************/
-
-#include "mioInt.h"
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-char *            Mio_LibraryReadName          ( Mio_Library_t * pLib )  { return pLib->pName;    }
-int               Mio_LibraryReadGateNum       ( Mio_Library_t * pLib )  { return pLib->nGates;   }
-Mio_Gate_t *      Mio_LibraryReadGates         ( Mio_Library_t * pLib )  { return pLib->pGates;   }
-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_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 []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Mio_Gate_t * Mio_LibraryReadGateByName( Mio_Library_t * pLib, char * pName )      
-{ 
-    Mio_Gate_t * pGate;
-    if ( st_lookup( pLib->tName2Gate, pName, (char **)&pGate ) )
-        return pGate;
-    return NULL;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Read Mvc of the gate by name.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-char * Mio_LibraryReadSopByName( Mio_Library_t * pLib, char * pName )      
-{ 
-    Mio_Gate_t * pGate;
-    if ( st_lookup( pLib->tName2Gate, pName, (char **)&pGate ) )
-        return pGate->pSop;
-    return NULL;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-char *            Mio_GateReadName    ( Mio_Gate_t * pGate )           { return pGate->pName;     }
-char *            Mio_GateReadOutName ( Mio_Gate_t * pGate )           { return pGate->pOutName;  }
-double            Mio_GateReadArea    ( Mio_Gate_t * pGate )           { return pGate->dArea;     }
-char *            Mio_GateReadForm    ( Mio_Gate_t * pGate )           { return pGate->pForm;     }
-Mio_Pin_t *       Mio_GateReadPins    ( Mio_Gate_t * pGate )           { return pGate->pPins;     }
-Mio_Library_t *   Mio_GateReadLib     ( Mio_Gate_t * pGate )           { return pGate->pLib;      }
-Mio_Gate_t *      Mio_GateReadNext    ( Mio_Gate_t * pGate )           { return pGate->pNext;     }
-int               Mio_GateReadInputs  ( Mio_Gate_t * pGate )           { return pGate->nInputs;   }
-double            Mio_GateReadDelayMax( Mio_Gate_t * pGate )           { return pGate->dDelayMax; }
-char *            Mio_GateReadSop     ( Mio_Gate_t * pGate )           { return pGate->pSop;      }
-DdNode *          Mio_GateReadFunc    ( Mio_Gate_t * pGate )           { return pGate->bFunc;     }
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-char *            Mio_PinReadName           ( Mio_Pin_t * pPin )      { return pPin->pName;           }
-Mio_PinPhase_t    Mio_PinReadPhase          ( Mio_Pin_t * pPin )      { return pPin->Phase;           }
-double            Mio_PinReadInputLoad      ( Mio_Pin_t * pPin )      { return pPin->dLoadInput;      }
-double            Mio_PinReadMaxLoad        ( Mio_Pin_t * pPin )      { return pPin->dLoadMax;        }
-double            Mio_PinReadDelayBlockRise ( Mio_Pin_t * pPin )      { return pPin->dDelayBlockRise; }
-double            Mio_PinReadDelayFanoutRise( Mio_Pin_t * pPin )      { return pPin->dDelayFanoutRise;}
-double            Mio_PinReadDelayBlockFall ( Mio_Pin_t * pPin )      { return pPin->dDelayBlockFall; }
-double            Mio_PinReadDelayFanoutFall( Mio_Pin_t * pPin )      { return pPin->dDelayFanoutFall;}
-double            Mio_PinReadDelayBlockMax  ( Mio_Pin_t * pPin )      { return pPin->dDelayBlockMax;          }
-Mio_Pin_t *       Mio_PinReadNext           ( Mio_Pin_t * pPin )      { return pPin->pNext;           }
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
diff --git a/src/map/mio/mioFunc.c b/src/map/mio/mioFunc.c
deleted file mode 100644
index 21a078f9..00000000
--- a/src/map/mio/mioFunc.c
+++ /dev/null
@@ -1,268 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [mioFunc.c]
-
-  PackageName [MVSIS 1.3: Multi-valued logic synthesis system.]
-
-  Synopsis    [File reading/writing for technology mapping.]
-
-  Author      [MVSIS Group]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - September 8, 2003.]
-
-  Revision    [$Id: mioFunc.c,v 1.4 2004/06/28 14:20:25 alanmi Exp $]
-
-***********************************************************************/
-
-#include "mioInt.h"
-#include "parse.h"
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-// these symbols (and no other) can appear in the formulas
-#define MIO_SYMB_AND    '*'
-#define MIO_SYMB_OR     '+'
-#define MIO_SYMB_NOT    '!'
-#define MIO_SYMB_AFTNOT '\''
-#define MIO_SYMB_OPEN   '('
-#define MIO_SYMB_CLOSE  ')'
-
-static int Mio_GateParseFormula( Mio_Gate_t * pGate );
-static int Mio_GateCollectNames( char * pFormula, char * pPinNames[] );
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Deriving the functionality of the gates.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Mio_LibraryParseFormulas( Mio_Library_t * pLib )
-{
-    Mio_Gate_t * pGate;
-
-    // count the gates
-    pLib->nGates = 0;
-    Mio_LibraryForEachGate( pLib, pGate )
-        pLib->nGates++;        
-
-    // start a temporary BDD manager
-    pLib->dd = Cudd_Init( 20, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
-    // introduce ZDD variables
-    Cudd_zddVarsFromBddVars( pLib->dd, 2 );
-
-    // for each gate, derive its function
-    Mio_LibraryForEachGate( pLib, pGate )
-        if ( Mio_GateParseFormula( pGate ) )
-            return 1;
-    return 0;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Deriving the functionality of the gates.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Mio_GateParseFormula( Mio_Gate_t * pGate )
-{
-    DdManager * dd = pGate->pLib->dd;
-    char * pPinNames[100];
-    char * pPinNamesCopy[100];
-    Mio_Pin_t * pPin, ** ppPin;
-    int nPins, iPin, i;
-
-    // set the maximum delay of the gate; count pins
-    pGate->dDelayMax = 0.0;
-    nPins = 0;
-    Mio_GateForEachPin( pGate, pPin )
-    {
-        // set the maximum delay of the gate
-        if ( pGate->dDelayMax < pPin->dDelayBlockMax )
-            pGate->dDelayMax = pPin->dDelayBlockMax;
-        // count the pin
-        nPins++;
-    }
-
-    // check for the gate with const function
-    if ( nPins == 0 )
-    {
-        if ( strcmp( pGate->pForm, MIO_STRING_CONST0 ) == 0 )
-        {
-            pGate->bFunc = b0;
-            pGate->pSop = Abc_SopRegister( pGate->pLib->pMmFlex, " 0\n" );
-            pGate->pLib->pGate0 = pGate;
-        }
-        else if ( strcmp( pGate->pForm, MIO_STRING_CONST1 ) == 0 )
-        {
-            pGate->bFunc = b1;
-            pGate->pSop = Abc_SopRegister( pGate->pLib->pMmFlex, " 1\n" );
-            pGate->pLib->pGate1 = pGate;
-        }
-        else
-        {
-            printf( "Cannot parse formula \"%s\" of gate \"%s\".\n", pGate->pForm, pGate->pName );
-            return 1;
-        }
-        Cudd_Ref( pGate->bFunc );
-        return 0;
-    }
-
-    // collect the names as they appear in the formula
-    nPins = Mio_GateCollectNames( pGate->pForm, pPinNames );
-    if ( nPins == 0 )
-    {
-        printf( "Cannot read formula \"%s\" of gate \"%s\".\n", pGate->pForm, pGate->pName );
-        return 1;
-    }
-
-    // set the number of inputs
-    pGate->nInputs = nPins;
-
-    // consider the case when all the pins have identical pin info
-    if ( strcmp( pGate->pPins->pName, "*" ) == 0 )
-    {
-        // get the topmost (generic) pin
-        pPin = pGate->pPins;
-        FREE( pPin->pName );
-
-        // create individual pins from the generic pin
-        ppPin = &pPin->pNext;
-        for ( i = 1; i < nPins; i++ )
-        {
-            // get the new pin
-            *ppPin = Mio_PinDup( pPin );
-            // set its name
-            (*ppPin)->pName = pPinNames[i];
-            // prepare the next place in the list
-            ppPin = &((*ppPin)->pNext);
-        }
-        *ppPin = NULL;
-
-        // set the name of the topmost pin
-        pPin->pName = pPinNames[0];
-    }
-    else
-    {
-        // reorder the variable names to appear the save way as the pins
-        iPin = 0;
-        Mio_GateForEachPin( pGate, pPin )
-        {
-            // find the pin with the name pPin->pName
-            for ( i = 0; i < nPins; i++ )
-            {
-                if ( pPinNames[i] && strcmp( pPinNames[i], pPin->pName ) == 0 )
-                {
-                    // free pPinNames[i] because it is already available as pPin->pName
-                    // setting pPinNames[i] to NULL is useful to make sure that
-                    // this name is not assigned to two pins in the list
-                    FREE( pPinNames[i] );
-                    pPinNamesCopy[iPin++] = pPin->pName;
-                    break;
-                }
-                if ( i == nPins )
-                {
-                    printf( "Cannot find pin name \"%s\" in the formula \"%s\" of gate \"%s\".\n", 
-                        pPin->pName, pGate->pForm, pGate->pName );
-                    return 1;
-                }
-            }
-        }
-
-        // check for the remaining names
-        for ( i = 0; i < nPins; i++ )
-            if ( pPinNames[i] )
-            {
-                printf( "Name \"%s\" appears in the formula \"%s\" of gate \"%s\" but there is no such pin.\n", 
-                    pPinNames[i], pGate->pForm, pGate->pName );
-                return 1;
-            }
-
-        // copy the names back
-        memcpy( pPinNames, pPinNamesCopy, nPins * sizeof(char *) );
-    }
-
-    // expand the manager if necessary
-    if ( dd->size < nPins )
-    {
-        Cudd_Quit( dd );
-        dd = Cudd_Init( nPins + 10, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0 );
-        Cudd_zddVarsFromBddVars( dd, 2 );
-    }
-
-    // derive the formula as the BDD
-    pGate->bFunc = Parse_FormulaParser( stdout, pGate->pForm, nPins, 0, pPinNames, dd, dd->vars );
-    Cudd_Ref( pGate->bFunc );
-
-    // derive the cover (SOP)
-    pGate->pSop = Abc_ConvertBddToSop( pGate->pLib->pMmFlex, dd, pGate->bFunc, pGate->bFunc, nPins, 0, pGate->pLib->vCube, -1 );
-    return 0;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Collect the pin names in the formula.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Mio_GateCollectNames( char * pFormula, char * pPinNames[] )
-{
-    char Buffer[1000];
-    char * pTemp;
-    int nPins, i;
-
-    // save the formula as it was
-    strcpy( Buffer, pFormula );
-
-    // remove the non-name symbols
-    for ( pTemp = Buffer; *pTemp; pTemp++ )
-        if ( *pTemp == MIO_SYMB_AND  || *pTemp == MIO_SYMB_OR || *pTemp == MIO_SYMB_NOT
-          || *pTemp == MIO_SYMB_OPEN || *pTemp == MIO_SYMB_CLOSE || *pTemp == MIO_SYMB_AFTNOT )
-            *pTemp = ' ';
-
-    // save the names
-    nPins = 0;
-    pTemp = strtok( Buffer, " " );
-    while ( pTemp )
-    {
-        for ( i = 0; i < nPins; i++ )
-            if ( strcmp( pTemp, pPinNames[i] ) == 0 )
-                break;
-        if ( i == nPins )
-        { // cannot find this name; save it
-            pPinNames[nPins++] = Extra_UtilStrsav(pTemp);
-        }
-        // get the next name
-        pTemp = strtok( NULL, " " );
-    }
-    return nPins;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
diff --git a/src/map/mio/mioGENERIC.c b/src/map/mio/mioGENERIC.c
deleted file mode 100644
index 972c4ffc..00000000
--- a/src/map/mio/mioGENERIC.c
+++ /dev/null
@@ -1,46 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [mio___.c]
-
-  PackageName [MVSIS 1.3: Multi-valued logic synthesis system.]
-
-  Synopsis    [File reading/writing for technology mapping.]
-
-  Author      [MVSIS Group]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - September 8, 2003.]
-
-  Revision    [$Id: mio___.h,v 1.0 2003/09/08 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "mioInt.h"
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
diff --git a/src/map/mio/mioInt.h b/src/map/mio/mioInt.h
deleted file mode 100644
index 3f90b625..00000000
--- a/src/map/mio/mioInt.h
+++ /dev/null
@@ -1,125 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [mioInt.h]
-
-  PackageName [MVSIS 2.0: Multi-valued logic synthesis system.]
-
-  Synopsis    [File reading/writing for technology mapping.]
-
-  Author      [MVSIS Group]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - September 8, 2003.]
-
-  Revision    [$Id: mioInt.h,v 1.4 2004/06/28 14:20:25 alanmi Exp $]
-
-***********************************************************************/
-
-#ifndef __MIO_INT_H__
-#define __MIO_INT_H__
-
-////////////////////////////////////////////////////////////////////////
-///                          INCLUDES                                ///
-////////////////////////////////////////////////////////////////////////
-
-#include "abc.h"
-#include "mvc.h"
-#include "main.h"
-#include "mio.h"
-#include "extra.h"
-
-////////////////////////////////////////////////////////////////////////
-///                         PARAMETERS                               ///
-////////////////////////////////////////////////////////////////////////
-
-#define    MIO_STRING_GATE       "GATE"
-#define    MIO_STRING_PIN        "PIN"
-#define    MIO_STRING_NONINV     "NONINV"
-#define    MIO_STRING_INV        "INV"
-#define    MIO_STRING_UNKNOWN    "UNKNOWN"
-
-#define    MIO_STRING_CONST0     "CONST0"
-#define    MIO_STRING_CONST1     "CONST1"
- 
-// the bit masks
-#define    MIO_MASK(n)         ((~((unsigned)0)) >> (32-(n)))
-#define    MIO_FULL             (~((unsigned)0))
-
-////////////////////////////////////////////////////////////////////////
-///                    STRUCTURE DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-struct  Mio_LibraryStruct_t_
-{
-    char *             pName;       // the name of the library
-    int                nGates;      // the number of the gates
-    Mio_Gate_t *       pGates;      // the linked list of all gates in no particular order
-    Mio_Gate_t *       pGate0;      // the constant zero gate
-    Mio_Gate_t *       pGate1;      // the constant one gate
-    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
-    Vec_Str_t *        vCube;       // temporary cube
-}; 
-
-struct  Mio_GateStruct_t_
-{
-    // information derived from the genlib file
-    char *             pName;       // the name of the gate
-    double             dArea;       // the area of the gate
-    char *             pForm;       // the formula describing functionality of the gate
-    Mio_Pin_t *        pPins;       // the linked list of all pins (one pin if info is the same)
-    char *             pOutName;    // the name of the output pin 
-    // the library to which this gate belongs
-    Mio_Library_t *    pLib; 
-    // the next gate in the list
-    Mio_Gate_t *       pNext;    
-
-    // the derived information
-    int                nInputs;     // the number of inputs
-    double             dDelayMax;   // the maximum delay
-    DdNode *           bFunc;       // the functionality
-    char *             pSop;
-};
-
-struct  Mio_PinStruct_t_
-{
-    char *             pName;
-    Mio_PinPhase_t     Phase;
-    double             dLoadInput;
-    double             dLoadMax;
-    double             dDelayBlockRise;
-    double             dDelayFanoutRise;
-    double             dDelayBlockFall;
-    double             dDelayFanoutFall;
-    double             dDelayBlockMax;
-    Mio_Pin_t *        pNext;     
-};
-
-
-////////////////////////////////////////////////////////////////////////
-///                       GLOBAL VARIABLES                           ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                       MACRO DEFINITIONS                          ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/*=== mio.c =============================================================*/
-/*=== mioRead.c =============================================================*/
-/*=== mioUtils.c =============================================================*/
-
-#endif
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
diff --git a/src/map/mio/mioRead.c b/src/map/mio/mioRead.c
deleted file mode 100644
index 13c2cdcd..00000000
--- a/src/map/mio/mioRead.c
+++ /dev/null
@@ -1,582 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [mioRead.c]
-
-  PackageName [MVSIS 1.3: Multi-valued logic synthesis system.]
-
-  Synopsis    [File reading/writing for technology mapping.]
-
-  Author      [MVSIS Group]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - September 8, 2003.]
-
-  Revision    [$Id: mioRead.c,v 1.9 2004/10/19 06:40:16 satrajit Exp $]
-
-***********************************************************************/
-
-#include "mioInt.h"
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-static Mio_Library_t * Mio_LibraryReadOne( Abc_Frame_t * pAbc, char * FileName, bool fExtendedFormat, st_table * tExcludeGate, int fVerbose );
-static int          Mio_LibraryReadInternal( Mio_Library_t * pLib, char * pBuffer, bool fExtendedFormat, st_table * tExcludeGate, int fVerbose );
-static Mio_Gate_t * Mio_LibraryReadGate( char ** ppToken, bool fExtendedFormat );
-static Mio_Pin_t *  Mio_LibraryReadPin( char ** ppToken, bool fExtendedFormat );
-static char *       chomp( char *s );
-static void         Mio_LibraryDetectSpecialGates( Mio_Library_t * pLib );
-static void         Io_ReadFileRemoveComments( char * pBuffer, int * pnDots, int * pnLines );
-
-#ifdef WIN32
-extern int          isspace( int c );  // to silence the warning in VS
-#endif
-
-/**Function*************************************************************
-
-  Synopsis    [Read the genlib type of library.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Mio_Library_t * Mio_LibraryRead( void * pAbc, char * FileName, char * ExcludeFile, int fVerbose )
-{
-    Mio_Library_t * pLib;
-    int num;
-
-    st_table * tExcludeGate = 0;
-
-    if ( ExcludeFile )
-    {
-        tExcludeGate = st_init_table(strcmp, st_strhash);
-        if ( (num = Mio_LibraryReadExclude( pAbc, ExcludeFile, tExcludeGate )) == -1 )
-        {
-            st_free_table( tExcludeGate );
-            tExcludeGate = 0;
-            return 0;
-        }
-       
-        fprintf ( Abc_FrameReadOut( pAbc ), "Read %d gates from exclude file\n", num );
-    }
-
-    pLib = Mio_LibraryReadOne( pAbc, FileName, 0, tExcludeGate, fVerbose );       // try normal format first ..
-    if ( pLib == NULL )
-    {
-        pLib = Mio_LibraryReadOne( pAbc, FileName, 1, tExcludeGate, fVerbose );   // .. otherwise try extended format 
-        if ( pLib != NULL )
-            printf ( "Warning: Read extended GENLIB format but ignoring extensions\n" );
-    }
-
-    return pLib;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Read the genlib type of library.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Mio_Library_t * Mio_LibraryReadOne( Abc_Frame_t * pAbc, char * FileName, bool fExtendedFormat, st_table * tExcludeGate, int fVerbose )
-{
-    Mio_Library_t * pLib;
-    char * pBuffer = 0;
-
-    // allocate the genlib structure
-    pLib = ALLOC( Mio_Library_t, 1 );
-    memset( pLib, 0, sizeof(Mio_Library_t) );
-    pLib->pName = Extra_UtilStrsav( FileName );
-    pLib->tName2Gate = st_init_table(strcmp, st_strhash);
-    pLib->pMmFlex = Extra_MmFlexStart();
-    pLib->vCube = Vec_StrAlloc( 100 );
-
-    // read the file and clean comments
-    // pBuffer = Io_ReadFileFileContents( FileName, NULL );
-    // we don't use above function but actually do the same thing explicitly
-    // to handle open_path expansion correctly
-
-    {
-        FILE * pFile;
-        int nFileSize;
-
-        // open the BLIF file for binary reading
-        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 );
-        // get the file size, in bytes
-        fseek( pFile, 0, SEEK_END );  
-        nFileSize = ftell( pFile );  
-        // move the file current reading position to the beginning
-        rewind( pFile ); 
-        // load the contents of the file into memory
-        pBuffer   = ALLOC( char, nFileSize + 10 );
-        fread( pBuffer, nFileSize, 1, pFile );
-        // terminate the string with '\0'
-        pBuffer[ nFileSize ] = '\0';
-        strcat( pBuffer, "\n.end\n" );
-        // close file
-        fclose( pFile );
-    }
-
-    Io_ReadFileRemoveComments( pBuffer, NULL, NULL );
-
-    // parse the contents of the file
-    if ( Mio_LibraryReadInternal( pLib, pBuffer, fExtendedFormat, tExcludeGate, fVerbose ) )
-    {
-        Mio_LibraryDelete( pLib );
-        free( pBuffer );
-        return NULL;
-    }
-    free( pBuffer );
-
-    // derive the functinality of gates
-    if ( Mio_LibraryParseFormulas( pLib ) )
-    {
-        printf( "Mio_LibraryRead: Had problems parsing formulas.\n" );
-        Mio_LibraryDelete( pLib );
-        return NULL;
-    }
-
-    // detect INV and NAND2
-    Mio_LibraryDetectSpecialGates( pLib );
-//Mio_WriteLibrary( stdout, pLib );
-    return pLib;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Read the genlib type of library.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Mio_LibraryReadInternal( Mio_Library_t * pLib, char * pBuffer, bool fExtendedFormat, st_table * tExcludeGate, int fVerbose )
-{
-    Mio_Gate_t * pGate, ** ppGate;
-    char * pToken;
-    int nGates = 0;
-    int nDel = 0;
-
-    // start the linked list of gates
-    pLib->pGates = NULL;
-    ppGate = &pLib->pGates;
-
-    // read gates one by one
-    pToken = strtok( pBuffer, " \t\r\n" );
-    while ( pToken && strcmp( pToken, MIO_STRING_GATE ) == 0 )
-    {
-        // derive the next gate
-        pGate = Mio_LibraryReadGate( &pToken, fExtendedFormat );
-        if ( pGate == NULL )
-            return 1;
-        
-        // set the library
-        pGate->pLib = pLib;
-
-        // printf ("Processing: '%s'\n", pGate->pName);
-
-        if ( tExcludeGate && st_is_member( tExcludeGate, pGate->pName ) )
-        {
-            //printf ("Excluding: '%s'\n", pGate->pName);
-            Mio_GateDelete( pGate );
-            nDel++;
-        } 
-        else
-        {
-            // add this gate to the list
-            *ppGate = pGate;
-            ppGate  = &pGate->pNext;
-            nGates++;
-
-            // remember this gate by name
-            if ( !st_is_member( pLib->tName2Gate, pGate->pName ) )
-                st_insert( pLib->tName2Gate, pGate->pName, (char *)pGate );
-            else
-                printf( "The gate with name \"%s\" appears more than once.\n", pGate->pName );
-        }
-    }
-    if ( fVerbose )
-    printf( "The number of gates read = %d.\n", nGates );
-
-    // check what is the last word read
-    if ( pToken && strcmp( pToken, ".end" ) != 0 )
-        return 1;
-
-    if ( nDel != 0 ) 
-        printf( "Actually excluded %d cells\n", nDel );
-
-    return 0;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Read the genlib type of gate.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Mio_Gate_t * Mio_LibraryReadGate( char ** ppToken, bool fExtendedFormat )
-{
-    Mio_Gate_t * pGate;
-    Mio_Pin_t * pPin, ** ppPin;
-    char * pToken = *ppToken;
-
-    // allocate the gate structure
-    pGate = ALLOC( Mio_Gate_t, 1 );
-    memset( pGate, 0, sizeof(Mio_Gate_t) );
-
-    // read the name
-    pToken = strtok( NULL, " \t\r\n" );
-    pGate->pName = Extra_UtilStrsav( pToken );
-
-    // read the area
-    pToken = strtok( NULL, " \t\r\n" );
-    pGate->dArea = atof( pToken );
-
-    // read the formula
-
-    // first the output name
-    pToken = strtok( NULL, "=" );
-    pGate->pOutName = chomp( pToken );
-
-    // then rest of the expression 
-    pToken = strtok( NULL, ";" );
-    pGate->pForm = Extra_UtilStrsav( pToken );
-
-    // read the pin info
-    // start the linked list of pins
-    pGate->pPins = NULL;
-    ppPin = &pGate->pPins;
-
-    // read gates one by one
-    pToken = strtok( NULL, " \t\r\n" );
-    while ( pToken && strcmp( pToken, MIO_STRING_PIN ) == 0 )
-    {
-        // derive the next gate
-        pPin = Mio_LibraryReadPin( &pToken, fExtendedFormat );
-        if ( pPin == NULL )
-        {
-            Mio_GateDelete( pGate );
-            *ppToken = pToken;
-            return NULL;
-        }
-        // add this pin to the list
-        *ppPin = pPin;
-        ppPin  = &pPin->pNext;
-        // get the next token
-        pToken = strtok( NULL, " \t\r\n" );
-    }
-
-    *ppToken = pToken;
-    return pGate;
-}
-
-
-
-/**Function*************************************************************
-
-  Synopsis    [Read the genlib type of pin.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Mio_Pin_t * Mio_LibraryReadPin( char ** ppToken, bool fExtendedFormat )
-{
-    Mio_Pin_t * pPin;
-    char * pToken = *ppToken;
-
-    // allocate the gate structure
-    pPin = ALLOC( Mio_Pin_t, 1 );
-    memset( pPin, 0, sizeof(Mio_Pin_t) );
-
-    // read the name
-    pToken = strtok( NULL, " \t\r\n" );
-    pPin->pName = Extra_UtilStrsav( pToken );
-
-    // read the pin phase
-    pToken = strtok( NULL, " \t\r\n" );
-    if ( strcmp( pToken, MIO_STRING_UNKNOWN ) == 0 )
-        pPin->Phase = MIO_PHASE_UNKNOWN;
-    else if ( strcmp( pToken, MIO_STRING_INV ) == 0 )
-        pPin->Phase = MIO_PHASE_INV;
-    else if ( strcmp( pToken, MIO_STRING_NONINV ) == 0 )
-        pPin->Phase = MIO_PHASE_NONINV;
-    else 
-    {
-        printf( "Cannot read pin phase specification\n" );
-        Mio_PinDelete( pPin );
-        *ppToken = pToken;
-        return NULL;
-    }
-
-    pToken = strtok( NULL, " \t\r\n" );
-    pPin->dLoadInput = atof( pToken );
-
-    pToken = strtok( NULL, " \t\r\n" );
-    pPin->dLoadMax = atof( pToken );
-
-    pToken = strtok( NULL, " \t\r\n" );
-    pPin->dDelayBlockRise = atof( pToken );
-
-    pToken = strtok( NULL, " \t\r\n" );
-    pPin->dDelayFanoutRise = atof( pToken );
-
-    pToken = strtok( NULL, " \t\r\n" );
-    pPin->dDelayBlockFall = atof( pToken );
-
-    pToken = strtok( NULL, " \t\r\n" );
-    pPin->dDelayFanoutFall = atof( pToken );
-
-    if ( fExtendedFormat )
-    {
-        /* In extended format, the field after dDelayFanoutRise
-         * is to be ignored
-         **/
-
-        pPin->dDelayBlockFall  = pPin->dDelayFanoutFall;
-
-        pToken = strtok( NULL, " \t" );
-        pPin->dDelayFanoutFall = atof( pToken );
-
-        /* last field is ignored */
-        pToken = strtok( NULL, " \t\r\n" );
-    }
-
-    if ( pPin->dDelayBlockRise > pPin->dDelayBlockFall )
-        pPin->dDelayBlockMax = pPin->dDelayBlockRise;
-    else
-        pPin->dDelayBlockMax = pPin->dDelayBlockFall;
-
-    *ppToken = pToken;
-    return pPin;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Duplicates string and returns it with leading and 
-               trailing spaces removed.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-char *chomp( char *s )
-{
-    char *b = ALLOC(char, strlen(s)+1), *c = b;
-    while (*s && isspace(*s))
-        ++s;
-    while (*s && !isspace(*s))
-        *c++ = *s++;
-    *c = 0;
-    return b;
-}   
-        
-/**Function*************************************************************
-
-  Synopsis    [Duplicates string and returns it with leading and 
-               trailing spaces removed.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Mio_LibraryDetectSpecialGates( Mio_Library_t * pLib )
-{
-    Mio_Gate_t * pGate;
-    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 )
-        {
-            pLib->pGateBuf = pGate;
-            break;
-        }
-    if ( pLib->pGateBuf == NULL )
-    {
-        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 )
-        {
-            pLib->pGateInv = pGate;
-            break;
-        }
-    if ( pLib->pGateInv == NULL )
-    {
-        printf( "Warnings: GENLIB library reader cannot detect the invertor gate.\n" );
-        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;
-        }
-    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 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*************************************************************
-
-  Synopsis    [populate hash table of gates to be exlcuded from genlib]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Mio_LibraryReadExclude( void * pAbc, char * ExcludeFile, st_table * tExcludeGate )
-{
-    int nDel = 0;
-    FILE *pEx;
-    char buffer[128];
-
-    assert ( tExcludeGate );
-
-    if ( ExcludeFile )
-    {
-        pEx = fopen( ExcludeFile, "r" );
-
-        if ( pEx == NULL )
-        {
-            fprintf ( Abc_FrameReadErr( pAbc ), "Error: Could not open exclude file %s. Stop.\n", ExcludeFile );
-            return -1;
-        }
-
-        while (1 == fscanf( pEx, "%127s", buffer ))
-        {
-            //printf ("Read: '%s'\n", buffer );
-            st_insert( tExcludeGate, Extra_UtilStrsav( buffer ), (char *)0 );
-            nDel++;
-        }
-
-        fclose( pEx );
-    }
-
-    return nDel;
-}
-    
-/**Function*************************************************************
-
-  Synopsis    [Eliminates comments from the input file.]
-
-  Description [As a byproduct, this procedure also counts the number
-  lines and dot-statements in the input file. This also joins non-comment 
-  lines that are joined with a backspace '\']
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Io_ReadFileRemoveComments( char * pBuffer, int * pnDots, int * pnLines )
-{
-    char * pCur;
-    int nDots, nLines;
-    // scan through the buffer and eliminate comments
-    // (in the BLIF file, comments are lines starting with "#")
-    nDots = nLines = 0;
-    for ( pCur = pBuffer; *pCur; pCur++ )
-    {
-        // if this is the beginning of comment
-        // clean it with spaces until the new line statement
-        if ( *pCur == '#' )
-            while ( *pCur != '\n' )
-                *pCur++ = ' ';
-    
-        // count the number of new lines and dots
-        if ( *pCur == '\n' ) {
-        if (*(pCur-1)=='\r') {
-        // DOS(R) file support
-        if (*(pCur-2)!='\\') nLines++;
-        else {
-            // rewind to backslash and overwrite with a space
-            *(pCur-2) = ' ';
-            *(pCur-1) = ' ';
-            *pCur = ' ';
-        }
-        } else {
-        // UNIX(TM) file support
-        if (*(pCur-1)!='\\') nLines++;
-        else {
-            // rewind to backslash and overwrite with a space
-            *(pCur-1) = ' ';
-            *pCur = ' ';
-        }
-        }
-    }
-        else if ( *pCur == '.' )
-            nDots++;
-    }
-    if ( pnDots )
-        *pnDots = nDots; 
-    if ( pnLines )
-        *pnLines = nLines; 
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
diff --git a/src/map/mio/mioUtils.c b/src/map/mio/mioUtils.c
deleted file mode 100644
index bd3d01f7..00000000
--- a/src/map/mio/mioUtils.c
+++ /dev/null
@@ -1,531 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [mioUtils.c]
-
-  PackageName [MVSIS 1.3: Multi-valued logic synthesis system.]
-
-  Synopsis    [File reading/writing for technology mapping.]
-
-  Author      [MVSIS Group]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - September 8, 2003.]
-
-  Revision    [$Id: mioUtils.c,v 1.6 2004/09/03 18:02:20 satrajit Exp $]
-
-***********************************************************************/
-
-#include "mioInt.h"
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-static void Mio_WriteGate( FILE * pFile, Mio_Gate_t * pGate, int fPrintSops );
-static void Mio_WritePin( FILE * pFile, Mio_Pin_t * pPin );
-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 DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Mio_LibraryDelete( Mio_Library_t * pLib )
-{
-    Mio_Gate_t * pGate, * pGate2;
-    if ( pLib == NULL )
-        return;
-    // free the bindings of nodes to gates from this library for all networks
-    Abc_FrameUnmapAllNetworks( Abc_FrameGetGlobalFrame() );
-    // free the library
-    FREE( pLib->pName );
-    Mio_LibraryForEachGateSafe( pLib, pGate, pGate2 )
-        Mio_GateDelete( pGate );
-    Extra_MmFlexStop( pLib->pMmFlex );
-    Vec_StrFree( pLib->vCube );
-    if ( pLib->tName2Gate )
-        st_free_table( pLib->tName2Gate );
-    if ( pLib->dd )
-        Cudd_Quit( pLib->dd );
-    free( pLib );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Mio_GateDelete( Mio_Gate_t * pGate )
-{
-    Mio_Pin_t * pPin, * pPin2;
-    FREE( pGate->pOutName );
-    FREE( pGate->pName );
-    FREE( pGate->pForm );
-    if ( pGate->bFunc )
-        Cudd_RecursiveDeref( pGate->pLib->dd, pGate->bFunc );
-    Mio_GateForEachPinSafe( pGate, pPin, pPin2 )
-        Mio_PinDelete( pPin );    
-    free( pGate );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Mio_PinDelete( Mio_Pin_t * pPin )
-{
-    FREE( pPin->pName );
-    free( pPin );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Mio_Pin_t * Mio_PinDup( Mio_Pin_t * pPin )
-{
-    Mio_Pin_t * pPinNew;
-
-    pPinNew = ALLOC( Mio_Pin_t, 1 );
-    *pPinNew = *pPin;
-    pPinNew->pName = (pPinNew->pName ? Extra_UtilStrsav(pPinNew->pName) : NULL);
-    pPinNew->pNext = NULL;
-
-    return pPinNew;
-}
-
-
-
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Mio_WriteLibrary( FILE * pFile, Mio_Library_t * pLib, int fPrintSops )
-{
-    Mio_Gate_t * pGate;
-
-    fprintf( pFile, "# The genlib library \"%s\".\n", pLib->pName );
-    Mio_LibraryForEachGate( pLib, pGate )
-        Mio_WriteGate( pFile, pGate, fPrintSops );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-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, "%10.2f   ",  pGate->dArea );
-    fprintf( pFile, "%s=%s;\n",   pGate->pOutName,    pGate->pForm );
-    // print the pins
-    if ( fPrintSops )
-        fprintf( pFile, "%s",       pGate->pSop? pGate->pSop : "unspecified\n" );
-//    Extra_bddPrint( pGate->pLib->dd, pGate->bFunc );
-//    fprintf( pFile, "\n" );
-    Mio_GateForEachPin( pGate, pPin )
-        Mio_WritePin( pFile, pPin );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Mio_WritePin( FILE * pFile, Mio_Pin_t * pPin )
-{
-    char * pPhaseNames[10] = { "UNKNOWN", "INV", "NONINV" };
-    fprintf( pFile, "    PIN " );
-    fprintf( pFile, "%9s ",     pPin->pName );
-    fprintf( pFile, "%10s ",    pPhaseNames[pPin->Phase] );
-    fprintf( pFile, "%6d ",     (int)pPin->dLoadInput );
-    fprintf( pFile, "%6d ",     (int)pPin->dLoadMax );
-    fprintf( pFile, "%6.2f ",   pPin->dDelayBlockRise );
-    fprintf( pFile, "%6.2f ",   pPin->dDelayFanoutRise );
-    fprintf( pFile, "%6.2f ",   pPin->dDelayBlockFall );
-    fprintf( pFile, "%6.2f",    pPin->dDelayFanoutFall );
-    fprintf( pFile, "\n" );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Collects the set of root gates.]
-
-  Description [Only collects the gates with unique functionality, 
-  which have fewer inputs and shorter delay than the given limits.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Mio_Gate_t ** Mio_CollectRoots( Mio_Library_t * pLib, int nInputs, float tDelay, bool fSkipInv, int * pnGates )
-{
-    Mio_Gate_t * pGate;
-    Mio_Gate_t ** ppGates;
-    /* st_table * tFuncs; */
-    /* st_generator * gen; */
-    DdNode * bFunc;
-    DdManager * dd;
-    int nGates, iGate;
-
-    dd     = Mio_LibraryReadDd( pLib );
-    nGates = Mio_LibraryReadGateNum( pLib );
-
-    /*
-
-    // for each functionality select one gate; skip constants and buffers
-    tFuncs = st_init_table( st_ptrcmp, st_ptrhash );
-    Mio_LibraryForEachGate( pLib, pGate )
-    {
-        bFunc = Mio_GateReadFunc(pGate);
-        if ( pGate->nInputs > nInputs )
-            continue;
-        if ( pGate->dDelayMax > (double)tDelay )
-            continue;
-        if ( bFunc == b0 || bFunc == b1 )
-            continue;
-        if ( bFunc == dd->vars[0] )
-            continue;
-        if ( bFunc == Cudd_Not(dd->vars[0]) && fSkipInv )
-            continue;
-        if ( st_is_member( tFuncs, (char *)bFunc ) )
-            continue;
-        st_insert( tFuncs, (char *)bFunc, (char *)pGate );
-    }
-
-    // collect the gates into the array
-    ppGates = ALLOC( Mio_Gate_t *, nGates );
-    iGate = 0;
-    st_foreach_item( tFuncs, gen, (char **)&bFunc, (char **)&pGate )
-        ppGates[ iGate++ ] = pGate;
-    assert( iGate <= nGates );
-    st_free_table( tFuncs );
-
-    */
-
-    ppGates = ALLOC( Mio_Gate_t *, nGates );
-    iGate = 0;
-    Mio_LibraryForEachGate( pLib, pGate )
-    {
-        bFunc = Mio_GateReadFunc(pGate);
-        if ( pGate->nInputs > nInputs )
-            continue;
-        if ( pGate->dDelayMax > (double)tDelay )
-            continue;
-        if ( bFunc == b0 || bFunc == b1 )
-            continue;
-        if ( bFunc == dd->vars[0] )
-            continue;
-        if ( bFunc == Cudd_Not(dd->vars[0]) && fSkipInv )
-            continue;
-
-        assert( iGate < nGates );
-        ppGates[ iGate++ ] = pGate;
-    }
-
-    if ( iGate > 0 )
-    {
-        // sort the gates by delay
-        qsort( (void *)ppGates, iGate, sizeof(Mio_Gate_t *), 
-                (int (*)(const void *, const void *)) Mio_DelayCompare );
-        assert( Mio_DelayCompare( ppGates, ppGates + iGate - 1 ) <= 0 );
-    }
-
-    if ( pnGates )
-        *pnGates = iGate;
-    return ppGates;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Compares the max delay of two gates.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Mio_DelayCompare( Mio_Gate_t ** ppG1, Mio_Gate_t ** ppG2 )
-{
-    if ( (*ppG1)->dDelayMax < (*ppG2)->dDelayMax )
-        return -1;
-    if ( (*ppG1)->dDelayMax > (*ppG2)->dDelayMax )
-        return 1;
-    return 0;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Derives the truth table of the gate.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Mio_DeriveTruthTable( Mio_Gate_t * pGate, unsigned uTruthsIn[][2], int nSigns, int nInputs, unsigned uTruthRes[] )
-{
-    Mio_DeriveTruthTable_rec( pGate->bFunc, uTruthsIn, uTruthRes );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Recursively derives the truth table of the gate.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Mio_DeriveTruthTable_rec( DdNode * bFunc, unsigned uTruthsIn[][2], unsigned uTruthRes[] )
-{
-    unsigned uTruthsCof0[2];
-    unsigned uTruthsCof1[2];
-
-    // complement the resulting truth table, if the function is complemented
-    if ( Cudd_IsComplement(bFunc) )
-    {
-        Mio_DeriveTruthTable_rec( Cudd_Not(bFunc), uTruthsIn, uTruthRes );
-        uTruthRes[0] = ~uTruthRes[0];
-        uTruthRes[1] = ~uTruthRes[1];
-        return;
-    }
-
-    // if the function is constant 1, return the constant 1 truth table
-    if ( bFunc->index == CUDD_CONST_INDEX )
-    {
-        uTruthRes[0] = MIO_FULL;
-        uTruthRes[1] = MIO_FULL;
-        return;
-    }
-
-    // solve the problem for both cofactors
-    Mio_DeriveTruthTable_rec( cuddE(bFunc), uTruthsIn, uTruthsCof0 );
-    Mio_DeriveTruthTable_rec( cuddT(bFunc), uTruthsIn, uTruthsCof1 );
-
-    // derive the resulting truth table using the input truth tables
-    uTruthRes[0] = (uTruthsCof0[0] & ~uTruthsIn[bFunc->index][0]) |
-                   (uTruthsCof1[0] &  uTruthsIn[bFunc->index][0]);
-    uTruthRes[1] = (uTruthsCof0[1] & ~uTruthsIn[bFunc->index][1]) |
-                   (uTruthsCof1[1] &  uTruthsIn[bFunc->index][1]);
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Derives the truth table of the root of the gate.]
-
-  Description [Given the truth tables of the leaves of the gate,
-  this procedure derives the truth table of the root.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Mio_DeriveTruthTable2( Mio_Gate_t * pGate, unsigned uTruthsIn[][2], int nTruths, int nInputs, unsigned uTruthRes[] )
-{
-    unsigned uSignCube[2];
-    int i, nFanins;
-    char * pCube;
-
-    // make sure that the number of input truth tables in equal to the number of gate inputs
-    assert( pGate->nInputs == nTruths );
-    assert( nInputs < 7 );
-
-    nFanins = Abc_SopGetVarNum( pGate->pSop );
-    assert( nFanins == nInputs );
-
-    // clean the resulting truth table
-    uTruthRes[0] = 0;
-    uTruthRes[1] = 0;
-    if ( nInputs < 6 )
-    {
-//        for ( c = 0; *(pCube = pGate->pSop + c * (nFanins + 3)); c++ )
-        Abc_SopForEachCube( pGate->pSop, nFanins, pCube )
-        {
-            // add the clause
-            uSignCube[0] = MIO_FULL;
-            for ( i = 0; i < nFanins; i++ )
-            {
-                if ( pCube[i] == '0' )
-                    uSignCube[0] &= ~uTruthsIn[i][0];
-                else if ( pCube[i] == '1' )
-                    uSignCube[0] &=  uTruthsIn[i][0];
-            }
-        }
-        if ( nInputs < 5 )
-            uTruthRes[0] &= MIO_MASK(1<<nInputs);
-    }
-    else
-    {
-        // consider the case when two unsigneds should be used
-//        for ( c = 0; *(pCube = pGate->pSop + c * (nFanins + 3)); c++ )
-        Abc_SopForEachCube( pGate->pSop, nFanins, pCube )
-        {
-            uSignCube[0] = MIO_FULL;
-            uSignCube[1] = MIO_FULL;
-            for ( i = 0; i < nFanins; i++ )
-            {
-                if ( pCube[i] == '0' )
-                {
-                    uSignCube[0] &= ~uTruthsIn[i][0];
-                    uSignCube[1] &= ~uTruthsIn[i][1];
-                }
-                else if ( pCube[i] == '1' )
-                {
-                    uSignCube[0] &=  uTruthsIn[i][0];
-                    uSignCube[1] &=  uTruthsIn[i][1];
-                }
-            }
-            uTruthRes[0] |= uSignCube[0];
-            uTruthRes[1] |= uSignCube[1];
-        }
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Derives the area and delay of the root of the gate.]
-
-  Description [Array of the resulting delays should be initialized 
-  to the (negative) SUPER_NO_VAR value.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Mio_DeriveGateDelays( Mio_Gate_t * pGate, 
-    float ** ptPinDelays, int nPins, int nInputs, float tDelayZero, 
-    float * ptDelaysRes, float * ptPinDelayMax )
-{
-    Mio_Pin_t * pPin;
-    float Delay, DelayMax;
-    int i, k;
-    assert( pGate->nInputs == nPins );
-    // set all the delays to the unused delay
-    for ( i = 0; i < nInputs; i++ )
-        ptDelaysRes[i] = tDelayZero;
-    // compute the delays for each input and the max delay at the same time
-    DelayMax = 0;
-    for ( i = 0; i < nInputs; i++ )
-    {
-        for ( k = 0, pPin = pGate->pPins; pPin; pPin = pPin->pNext, k++ )
-        {
-            if ( ptPinDelays[k][i] < 0 )
-                continue;
-            Delay = ptPinDelays[k][i] + (float)pPin->dDelayBlockMax;
-            if ( ptDelaysRes[i] < Delay )
-                ptDelaysRes[i] = Delay;
-        }
-        if ( k != nPins )
-        {
-            printf ("DEBUG: problem gate is %s\n", Mio_GateReadName( pGate ));
-        }
-        assert( k == nPins );
-        if ( DelayMax < ptDelaysRes[i] )
-            DelayMax = ptDelaysRes[i];
-    }
-    *ptPinDelayMax = DelayMax;
-}
-
-
-/**Function*************************************************************
-
-  Synopsis    [Creates a pseudo-gate.]
-
-  Description [The pseudo-gate is a N-input gate with all info set to 0.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Mio_Gate_t * Mio_GateCreatePseudo( int nInputs )
-{
-    Mio_Gate_t * pGate;
-    Mio_Pin_t * pPin;
-    int i;
-    // allocate the gate structure
-    pGate = ALLOC( Mio_Gate_t, 1 );
-    memset( pGate, 0, sizeof(Mio_Gate_t) );
-    pGate->nInputs = nInputs;
-    // create pins
-    for ( i = 0; i < nInputs; i++ )
-    {
-        pPin = ALLOC( Mio_Pin_t, 1 );
-        memset( pPin, 0, sizeof(Mio_Pin_t) );
-        pPin->pNext = pGate->pPins;
-        pGate->pPins = pPin;
-    }
-    return pGate;
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
diff --git a/src/map/mio/module.make b/src/map/mio/module.make
deleted file mode 100644
index 26a4561c..00000000
--- a/src/map/mio/module.make
+++ /dev/null
@@ -1,5 +0,0 @@
-SRC +=  src/map/mio/mio.c \
-    src/map/mio/mioApi.c \
-    src/map/mio/mioFunc.c \
-    src/map/mio/mioRead.c \
-    src/map/mio/mioUtils.c