ruby_abc 0.0.6 → 0.1.0

data/ext/abc/src/map/mio/mioUtils.c

@@ -1,1752 +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 <math.h>
-#include "mioInt.h"
-#include "base/main/main.h"
-#include "exp.h"
-#include "misc/util/utilTruth.h"
-#include "opt/dau/dau.h"
-#include "misc/util/utilNam.h"
-#include "map/scl/sclLib.h"
-#include "map/scl/sclCon.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                     FUNCTION DEFINITIONS                         ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Mio_LibraryDelete( Mio_Library_t * pLib )
-{
-    Mio_Gate_t * pGate, * pGate2;
-    if ( pLib == NULL )
-        return;
-    Mio_LibraryMatchesStop( pLib );
-    Mio_LibraryMatches2Stop( pLib );
-    // free the bindings of nodes to gates from this library for all networks
-    Abc_FrameUnmapAllNetworks( Abc_FrameGetGlobalFrame() );
-    // free the library
-    ABC_FREE( pLib->pName );
-    Mio_LibraryForEachGateSafe( pLib, pGate, pGate2 )
-        Mio_GateDelete( pGate );
-    Mem_FlexStop( pLib->pMmFlex, 0 );
-    Vec_StrFree( pLib->vCube );
-    if ( pLib->tName2Gate )
-        st__free_table( pLib->tName2Gate );
-//    if ( pLib->dd )
-//        Cudd_Quit( pLib->dd );
-    ABC_FREE( pLib->ppGates0 );
-    ABC_FREE( pLib->ppGatesName );
-    ABC_FREE( pLib );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Mio_GateDelete( Mio_Gate_t * pGate )
-{
-    Mio_Pin_t * pPin, * pPin2;
-    if ( pGate->nInputs > 6 )
-        ABC_FREE( pGate->pTruth );
-    Vec_IntFreeP( &pGate->vExpr );
-    ABC_FREE( pGate->pOutName );
-    ABC_FREE( pGate->pName );
-    ABC_FREE( pGate->pForm );
-//    if ( pGate->bFunc )
-//        Cudd_RecursiveDeref( pGate->pLib->dd, pGate->bFunc );
-    Mio_GateForEachPinSafe( pGate, pPin, pPin2 )
-        Mio_PinDelete( pPin );   
-    ABC_FREE( pGate );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Mio_PinDelete( Mio_Pin_t * pPin )
-{
-    ABC_FREE( pPin->pName );
-    ABC_FREE( pPin );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-Mio_Pin_t * Mio_PinDup( Mio_Pin_t * pPin )
-{
-    Mio_Pin_t * pPinNew;
-
-    pPinNew = ABC_ALLOC( Mio_Pin_t, 1 );
-    *pPinNew = *pPin;
-    pPinNew->pName = (pPinNew->pName ? Abc_UtilStrsav(pPinNew->pName) : NULL);
-    pPinNew->pNext = NULL;
-
-    return pPinNew;
-}
-
-
-
-
-/**Function*************************************************************
-
-  Synopsis    [Check if pin characteristics are the same.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Mio_CheckPins( Mio_Pin_t * pPin1, Mio_Pin_t * pPin2 )
-{
-    if ( pPin1 == NULL || pPin2 == NULL )
-        return 1;
-    if ( pPin1->dLoadInput != pPin2->dLoadInput )
-        return 0;
-    if ( pPin1->dLoadMax != pPin2->dLoadMax )
-        return 0;
-    if ( pPin1->dDelayBlockRise != pPin2->dDelayBlockRise )
-        return 0;
-    if ( pPin1->dDelayFanoutRise != pPin2->dDelayFanoutRise )
-        return 0;
-    if ( pPin1->dDelayBlockFall != pPin2->dDelayBlockFall )
-        return 0;
-    if ( pPin1->dDelayFanoutFall != pPin2->dDelayFanoutFall )
-        return 0;
-    return 1;
-}
-int Mio_CheckGates( Mio_Library_t * pLib )
-{
-    Mio_Gate_t * pGate;
-    Mio_Pin_t * pPin0 = NULL, * pPin = NULL;
-    Mio_LibraryForEachGate( pLib, pGate )
-        Mio_GateForEachPin( pGate, pPin )
-            if ( Mio_CheckPins( pPin0, pPin ) )
-                pPin0 = pPin;
-            else
-                return 0;
-    return 1;
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Mio_WritePin( FILE * pFile, Mio_Pin_t * pPin, int NameLen, int fAllPins )
-{
-    char * pPhaseNames[10] = { "UNKNOWN", "INV", "NONINV" };
-    if ( fAllPins )
-        fprintf( pFile, "PIN *  " );
-    else
-        fprintf( pFile, "\n    PIN %*s  ", NameLen, pPin->pName );
-    fprintf( pFile, "%7s ",   pPhaseNames[pPin->Phase] );
-    fprintf( pFile, "%3d ",   (int)pPin->dLoadInput );
-    fprintf( pFile, "%3d ",   (int)pPin->dLoadMax );
-    fprintf( pFile, "%8.2f ", pPin->dDelayBlockRise );
-    fprintf( pFile, "%8.2f ", pPin->dDelayFanoutRise );
-    fprintf( pFile, "%8.2f ", pPin->dDelayBlockFall );
-    fprintf( pFile, "%8.2f",  pPin->dDelayFanoutFall );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Mio_WriteGate( FILE * pFile, Mio_Gate_t * pGate, int GateLen, int NameLen, int FormLen, int fPrintSops, int fAllPins )
-{
-    char Buffer[5000];
-    Mio_Pin_t * pPin;
-    assert( NameLen+FormLen+2 < 5000 );
-    sprintf( Buffer, "%s=%s;",    pGate->pOutName, pGate->pForm );
-    fprintf( pFile, "GATE %-*s ", GateLen, pGate->pName );
-    fprintf( pFile, "%8.2f  ",    pGate->dArea );
-    fprintf( pFile, "%-*s ",      Abc_MinInt(NameLen+FormLen+2, 60), Buffer );
-    // print the pins
-    if ( fPrintSops )
-        fprintf( pFile, "%s",       pGate->pSop? pGate->pSop : "unspecified\n" );
-    if ( fAllPins && pGate->pPins ) // equal pins
-        Mio_WritePin( pFile, pGate->pPins, NameLen, 1 );
-    else // different pins
-        Mio_GateForEachPin( pGate, pPin )
-            Mio_WritePin( pFile, pPin, NameLen, 0 );
-    fprintf( pFile, "\n" );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Mio_WriteLibrary( FILE * pFile, Mio_Library_t * pLib, int fPrintSops, int fShort, int fSelected )
-{
-    Mio_Gate_t * pGate;
-    Mio_Pin_t * pPin;
-    Vec_Ptr_t * vGates = Vec_PtrAlloc( 1000 );
-    int i, nCells, GateLen = 0, NameLen = 0, FormLen = 0;
-    int fAllPins = fShort || Mio_CheckGates( pLib );
-    if ( fSelected )
-    {
-        Mio_Cell2_t * pCells = Mio_CollectRootsNewDefault2( 6, &nCells, 0 );
-        for ( i = 0; i < nCells; i++ )
-            Vec_PtrPush( vGates, pCells[i].pMioGate );
-        ABC_FREE( pCells );
-    }
-    else
-    {
-        for ( i = 0; i < pLib->nGates; i++ )
-            Vec_PtrPush( vGates, pLib->ppGates0[i] );
-    }
-    Vec_PtrForEachEntry( Mio_Gate_t *, vGates, pGate, i )
-    {
-        GateLen = Abc_MaxInt( GateLen, strlen(pGate->pName) );
-        NameLen = Abc_MaxInt( NameLen, strlen(pGate->pOutName) );
-        FormLen = Abc_MaxInt( FormLen, strlen(pGate->pForm) );
-        Mio_GateForEachPin( pGate, pPin )
-            NameLen = Abc_MaxInt( NameLen, strlen(pPin->pName) );
-    }
-    fprintf( pFile, "# The genlib library \"%s\" with %d gates written by ABC on %s\n", pLib->pName, Vec_PtrSize(vGates), Extra_TimeStamp() );
-    Vec_PtrForEachEntry( Mio_Gate_t *, vGates, pGate, i )
-        Mio_WriteGate( pFile, pGate, GateLen, NameLen, FormLen, fPrintSops, fAllPins );
-    Vec_PtrFree( vGates );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Compares the max delay of two gates.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Mio_DelayCompare( Mio_Gate_t ** ppG1, Mio_Gate_t ** ppG2 )
-{
-    int Comp;
-    float Eps = (float)0.0094636;
-    if ( (*ppG1)->dDelayMax < (*ppG2)->dDelayMax - Eps )
-        return -1;
-    if ( (*ppG1)->dDelayMax > (*ppG2)->dDelayMax + Eps )
-        return 1;
-    // compare names
-    Comp = strcmp( (*ppG1)->pName, (*ppG2)->pName );
-    if ( Comp < 0 )
-        return -1;
-    if ( Comp > 0 )
-        return 1;
-    assert( 0 );
-    return 0;
-}
-int Mio_AreaCompare( Mio_Cell_t * pG1, Mio_Cell_t * pG2 )
-{
-    int Comp;
-    float Eps = (float)0.0094636;
-    if ( pG1->nFanins < pG2->nFanins )
-        return -1;
-    if ( pG1->nFanins > pG2->nFanins )
-        return 1;
-    if ( pG1->Area < pG2->Area - Eps )
-        return -1;
-    if ( pG1->Area > pG2->Area + Eps )
-        return 1;
-    // compare names
-    Comp = strcmp( pG1->pName, pG2->pName );
-    if ( Comp < 0 )
-        return -1;
-    if ( Comp > 0 )
-        return 1;
-    assert( 0 );
-    return 0;
-}
-int Mio_AreaCompare2( Mio_Cell2_t * pG1, Mio_Cell2_t * pG2 )
-{
-    int Comp;
-    if ( pG1->nFanins < pG2->nFanins )
-        return -1;
-    if ( pG1->nFanins > pG2->nFanins )
-        return 1;
-    if ( pG1->AreaW < pG2->AreaW )
-        return -1;
-    if ( pG1->AreaW > pG2->AreaW )
-        return 1;
-    // compare names
-    Comp = strcmp( pG1->pName, pG2->pName );
-    if ( Comp < 0 )
-        return -1;
-    if ( Comp > 0 )
-        return 1;
-    assert( 0 );
-    return 0;
-}
-
-/**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     []
-
-***********************************************************************/
-static inline float Mio_CellDelayAve( Mio_Cell_t * pCell )
-{
-    float CellDelay = 0; int k;
-    for ( k = 0; k < (int)pCell->nFanins; k++ )
-        CellDelay += pCell->Delays[k];
-    if ( pCell->nFanins )
-        CellDelay /= pCell->nFanins;
-    return CellDelay;
-}
-static inline float Mio_GateDelayAve( Mio_Gate_t * pGate )
-{
-    float GateDelay = 0;
-    Mio_Pin_t * pPin; 
-    Mio_GateForEachPin( pGate, pPin )
-        GateDelay += (float)(0.5 * pPin->dDelayBlockRise + 0.5 * pPin->dDelayBlockFall);
-    if ( pGate->nInputs )
-        GateDelay /= pGate->nInputs;
-    return GateDelay;
-}
-static inline int Mio_CompareTwoGates( Mio_Gate_t * pCell, Mio_Gate_t * pGate )
-{
-    int Comp;
-    float Eps = (float)0.0094636;
-    float CellDelay, GateDelay;
-    // compare areas
-    if ( pCell->dArea > (float)pGate->dArea + Eps )
-        return 1;
-    if ( pCell->dArea < (float)pGate->dArea - Eps )
-        return 0;
-    // compare delays
-    CellDelay = Mio_GateDelayAve( pCell );
-    GateDelay = Mio_GateDelayAve( pGate );
-    if ( CellDelay > GateDelay + Eps )
-        return 1;
-    if ( CellDelay < GateDelay - Eps )
-        return 0;
-    // compare names
-    Comp = strcmp( pCell->pName, pGate->pName );
-    if ( Comp > 0 )
-        return 1;
-    if ( Comp < 0 )
-        return 0;
-    assert( 0 );
-    return 0;
-}
-Mio_Gate_t ** Mio_CollectRoots( Mio_Library_t * pLib, int nInputs, float tDelay, int fSkipInv, int * pnGates, int fVerbose )
-{
-    Mio_Gate_t * pGate;
-    Mio_Gate_t ** ppGates;
-    int i, nGates, iGate, fProfile;
-    nGates = Mio_LibraryReadGateNum( pLib );
-    ppGates = ABC_ALLOC( Mio_Gate_t *, nGates );
-    iGate = 0;
-    // check if profile is entered
-    fProfile = Mio_LibraryHasProfile( pLib );
-    if ( fProfile )
-        printf( "Mio_CollectRoots(): Using gate profile to select gates for mapping.\n" );
-    // for each functionality, select gate with the smallest area
-    // if equal areas, select gate with lexicographically smaller name
-    Mio_LibraryForEachGate( pLib, pGate )
-    {
-        if ( pGate->nInputs > nInputs )
-            continue;
-        if ( fProfile && Mio_GateReadProfile(pGate) == 0 && pGate->nInputs > 1 )
-            continue;
-        if ( tDelay > 0.0 && pGate->dDelayMax > (double)tDelay )
-            continue;
-        if ( pGate->uTruth == 0 || pGate->uTruth == ~(word)0 )
-            continue;
-        if ( pGate->uTruth == ABC_CONST(0xAAAAAAAAAAAAAAAA) )
-            continue;
-        if ( pGate->uTruth == ~ABC_CONST(0xAAAAAAAAAAAAAAAA) && fSkipInv )
-            continue;
-        if ( pGate->pTwin ) // skip multi-output gates for now
-            continue;
-        // check if the gate with this functionality already exists
-        for ( i = 0; i < iGate; i++ )
-            if ( ppGates[i]->uTruth == pGate->uTruth )
-            {
-                if ( Mio_CompareTwoGates(ppGates[i], pGate) )
-                    ppGates[i] = pGate;
-                break;
-            }
-        if ( i < iGate )
-            continue;
-        assert( iGate < nGates );
-        ppGates[ iGate++ ] = pGate;
-        if ( fVerbose )
-            printf( "Selected gate %3d:   %-20s  A = %7.2f  D = %7.2f  %3s = %-s\n", 
-                iGate+1, pGate->pName, pGate->dArea, pGate->dDelayMax, pGate->pOutName, pGate->pForm );
-    }
-    // sort by delay
-    if ( iGate > 0 ) 
-    {
-        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    [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     []
-
-***********************************************************************/
-static inline int Mio_CompareTwo( Mio_Cell_t * pCell, Mio_Gate_t * pGate )
-{
-    int Comp;
-    float Eps = (float)0.0094636;
-    float CellDelay, GateDelay;
-    // compare areas
-    if ( pCell->Area > (float)pGate->dArea + Eps )
-        return 1;
-    if ( pCell->Area < (float)pGate->dArea - Eps )
-        return 0;
-    // compare delays
-    CellDelay = Mio_CellDelayAve( pCell );
-    GateDelay = Mio_GateDelayAve( pGate );
-    if ( CellDelay > GateDelay + Eps )
-        return 1;
-    if ( CellDelay < GateDelay - Eps )
-        return 0;
-    // compare names
-    Comp = strcmp( pCell->pName, pGate->pName );
-    if ( Comp > 0 )
-        return 1;
-    if ( Comp < 0 )
-        return 0;
-    assert( 0 );
-    return 0;
-}
-static inline void Mio_CollectCopy( Mio_Cell_t * pCell, Mio_Gate_t * pGate )
-{
-    Mio_Pin_t * pPin;  int k;
-    pCell->pName   = pGate->pName;
-    pCell->uTruth  = pGate->uTruth;
-    pCell->Area    = (float)pGate->dArea;
-    pCell->nFanins = pGate->nInputs;
-    for ( k = 0, pPin = pGate->pPins; pPin; pPin = pPin->pNext, k++ )
-        pCell->Delays[k] = (float)(0.5 * pPin->dDelayBlockRise + 0.5 * pPin->dDelayBlockFall);
-}
-
-Mio_Cell_t * Mio_CollectRootsNew( Mio_Library_t * pLib, int nInputs, int * pnGates, int fVerbose )
-{
-    Mio_Gate_t * pGate;
-    Mio_Cell_t * ppCells;
-    int i, nGates, iCell = 4;
-    nGates = Mio_LibraryReadGateNum( pLib );
-    ppCells = ABC_CALLOC( Mio_Cell_t, nGates + 4 );
-    // for each functionality, select gate with the smallest area
-    // if equal areas, select gate with smaller average pin delay
-    // if these are also equal, select lexicographically smaller name
-    Mio_LibraryForEachGate( pLib, pGate )
-    {
-        if ( pGate->nInputs > nInputs || pGate->pTwin ) // skip large and multi-output
-            continue;
-        // check if the gate with this functionality already exists
-        for ( i = 0; i < iCell; i++ )
-            if ( ppCells[i].pName && ppCells[i].uTruth == pGate->uTruth )
-            {
-                if ( Mio_CompareTwo( ppCells + i, pGate ) )
-                    Mio_CollectCopy( ppCells + i, pGate );
-                break;
-            }
-        if ( i < iCell )
-            continue;
-        if ( pGate->uTruth == 0 || pGate->uTruth == ~(word)0 )
-        {
-            int Idx = (int)(pGate->uTruth == ~(word)0);
-            assert( pGate->nInputs == 0 );
-            Mio_CollectCopy( ppCells + Idx, pGate );
-            continue;
-        }
-        if ( pGate->uTruth == ABC_CONST(0xAAAAAAAAAAAAAAAA) || pGate->uTruth == ~ABC_CONST(0xAAAAAAAAAAAAAAAA) )
-        {
-            int Idx = 2 + (int)(pGate->uTruth == ~ABC_CONST(0xAAAAAAAAAAAAAAAA));
-            assert( pGate->nInputs == 1 );
-            Mio_CollectCopy( ppCells + Idx, pGate );
-            continue;
-        }
-        Mio_CollectCopy( ppCells + iCell++, pGate );
-    }
-    if ( ppCells[0].pName == NULL )
-        { printf( "Error: Cannot find constant 0 gate in the library.\n" ); return NULL; }
-    if ( ppCells[1].pName == NULL )
-        { printf( "Error: Cannot find constant 1 gate in the library.\n" ); return NULL; }
-    if ( ppCells[2].pName == NULL )
-        { printf( "Error: Cannot find buffer gate in the library.\n" );     return NULL; }
-    if ( ppCells[3].pName == NULL )
-        { printf( "Error: Cannot find inverter gate in the library.\n" );   return NULL; }
-    // sort by delay
-    if ( iCell > 5 ) 
-    {
-        qsort( (void *)(ppCells + 4), iCell - 4, sizeof(Mio_Cell_t), 
-                (int (*)(const void *, const void *)) Mio_AreaCompare );
-        assert( Mio_AreaCompare( ppCells + 4, ppCells + iCell - 1 ) <= 0 );
-    }
-    // assign IDs
-    for ( i = 0; i < iCell; i++ )
-        ppCells[i].Id = ppCells[i].pName ? i : -1;
-
-    // report
-    if ( fVerbose )
-    {
-        // count gates
-        int * pCounts = ABC_CALLOC( int, nGates + 4 );
-        Mio_LibraryForEachGate( pLib, pGate )
-        {
-            if ( pGate->nInputs > nInputs || pGate->pTwin ) // skip large and multi-output
-                continue;
-            for ( i = 0; i < iCell; i++ )
-                if ( ppCells[i].pName && ppCells[i].uTruth == pGate->uTruth )
-                {
-                    pCounts[i]++;
-                    break;
-                }
-            assert( i < iCell );
-        }
-        for ( i = 0; i < iCell; i++ )
-        {
-            Mio_Cell_t * pCell = ppCells + i;
-            printf( "%4d : ", i );
-            if ( pCell->pName == NULL )
-                printf( "None\n" );
-            else
-                printf( "%-20s   In = %d   N = %3d   A = %12.6f   D = %12.6f\n", 
-                    pCell->pName, pCell->nFanins, pCounts[i], pCell->Area, Mio_CellDelayAve(pCell) );
-        }
-        ABC_FREE( pCounts );
-    }
-    if ( pnGates )
-        *pnGates = iCell;
-    return ppCells;
-}
-Mio_Cell_t * Mio_CollectRootsNewDefault( int nInputs, int * pnGates, int fVerbose )
-{
-    return Mio_CollectRootsNew( (Mio_Library_t *)Abc_FrameReadLibGen(), nInputs, pnGates, fVerbose );
-}
-
-/**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     []
-
-***********************************************************************/
-static inline int Mio_CompareTwo2( Mio_Cell2_t * pCell1, Mio_Cell2_t * pCell2 )
-{
-    int Comp;
-    // compare areas
-    if ( pCell1->AreaW > pCell2->AreaW )
-        return 1;
-    if ( pCell1->AreaW < pCell2->AreaW )
-        return 0;
-    // compare delays
-    if ( pCell1->iDelayAve > pCell2->iDelayAve )
-        return 1;
-    if ( pCell1->iDelayAve < pCell2->iDelayAve )
-        return 0;
-    // compare names
-    Comp = strcmp( pCell1->pName, pCell2->pName );
-    if ( Comp > 0 )
-        return 1;
-    if ( Comp < 0 )
-        return 0;
-    assert( 0 );
-    return 0;
-}
-static inline void Mio_CollectCopy2( Mio_Cell2_t * pCell, Mio_Gate_t * pGate )
-{
-    Mio_Pin_t * pPin;  int k;
-    pCell->pName     = pGate->pName;
-    pCell->vExpr     = pGate->vExpr;
-    pCell->uTruth    = pGate->uTruth;
-    pCell->AreaF     = pGate->dArea;
-    pCell->AreaW     = (word)(SCL_NUM * pGate->dArea);
-    pCell->nFanins   = pGate->nInputs;
-    pCell->pMioGate  = pGate;
-    pCell->iDelayAve = 0;
-    for ( k = 0, pPin = pGate->pPins; pPin; pPin = pPin->pNext, k++ )
-    {
-        pCell->iDelays[k] = (int)(SCL_NUM/2 * pPin->dDelayBlockRise + SCL_NUM/2 * pPin->dDelayBlockFall);
-        pCell->iDelayAve += pCell->iDelays[k];
-    }
-    if ( pCell->nFanins )
-        pCell->iDelayAve /= pCell->nFanins;
-}
-
-Mio_Cell2_t * Mio_CollectRootsNew2( Mio_Library_t * pLib, int nInputs, int * pnGates, int fVerbose )
-{
-    Mio_Gate_t * pGate0;
-    Mio_Cell2_t * ppCells0, * ppCells, * pCell;
-    int i, nGates, iCell0 = 0, iCell = 4;
-    // create space for new cells
-    nGates = Mio_LibraryReadGateNum( pLib );
-    ppCells  = ABC_CALLOC( Mio_Cell2_t, nGates + 4 );
-    // copy all gates first
-    ppCells0 = ABC_CALLOC( Mio_Cell2_t, nGates );
-    Mio_LibraryForEachGate( pLib, pGate0 )
-        if ( !(pGate0->nInputs > nInputs || pGate0->pTwin) ) // skip large and multi-output
-            Mio_CollectCopy2( ppCells0 + iCell0++, pGate0 );
-    assert( iCell0 <= nGates );
-    // for each functionality, select gate with the smallest area
-    // if equal areas, select gate with smaller average pin delay
-    // if these are also equal, select lexicographically smaller name
-    for ( pCell = ppCells0; pCell < ppCells0 + iCell0; pCell++ )
-    {
-        // check if the gate with this functionality already exists
-        for ( i = 0; i < iCell; i++ )
-            if ( ppCells[i].pName && ppCells[i].uTruth == pCell->uTruth )
-            {
-                if ( Mio_CompareTwo2( ppCells + i, pCell ) )
-                    ppCells[i] = *pCell;
-                break;
-            }
-        if ( i < iCell )
-            continue;
-        if ( pCell->uTruth == 0 || pCell->uTruth == ~(word)0 )
-        {
-            int Idx = (int)(pCell->uTruth == ~(word)0);
-            assert( pCell->nFanins == 0 );
-            ppCells[Idx] = *pCell;
-            continue;
-        }
-        if ( pCell->uTruth == ABC_CONST(0xAAAAAAAAAAAAAAAA) || pCell->uTruth == ~ABC_CONST(0xAAAAAAAAAAAAAAAA) )
-        {
-            int Idx = 2 + (int)(pCell->uTruth == ~ABC_CONST(0xAAAAAAAAAAAAAAAA));
-            assert( pCell->nFanins == 1 );
-            ppCells[Idx] = *pCell;
-            continue;
-        }
-        ppCells[iCell++] = *pCell;
-    }
-    ABC_FREE( ppCells0 );
-    if ( ppCells[0].pName == NULL )
-        { printf( "Error: Cannot find constant 0 gate in the library.\n" ); return NULL; }
-    if ( ppCells[1].pName == NULL )
-        { printf( "Error: Cannot find constant 1 gate in the library.\n" ); return NULL; }
-    if ( ppCells[2].pName == NULL )
-        { printf( "Error: Cannot find buffer gate in the library.\n" );     return NULL; }
-    if ( ppCells[3].pName == NULL )
-        { printf( "Error: Cannot find inverter gate in the library.\n" );   return NULL; }
-    // sort by delay
-    if ( iCell > 5 ) 
-    {
-        qsort( (void *)(ppCells + 4), iCell - 4, sizeof(Mio_Cell2_t), 
-                (int (*)(const void *, const void *)) Mio_AreaCompare2 );
-        assert( Mio_AreaCompare2( ppCells + 4, ppCells + iCell - 1 ) <= 0 );
-    }
-    // assign IDs
-    Mio_LibraryForEachGate( pLib, pGate0 )
-        Mio_GateSetCell( pGate0, -1 );
-    for ( i = 0; i < iCell; i++ )
-    {
-        ppCells[i].Id = ppCells[i].pName ? i : -1;
-        Mio_GateSetCell( (Mio_Gate_t *)ppCells[i].pMioGate, i );
-    }
-
-    // report
-    if ( fVerbose )
-    {
-        // count gates
-        int * pCounts = ABC_CALLOC( int, nGates + 4 );
-        Mio_LibraryForEachGate( pLib, pGate0 )
-        {
-            if ( pGate0->nInputs > nInputs || pGate0->pTwin ) // skip large and multi-output
-                continue;
-            for ( i = 0; i < iCell; i++ )
-                if ( ppCells[i].pName && ppCells[i].uTruth == pGate0->uTruth )
-                {
-                    pCounts[i]++;
-                    break;
-                }
-            assert( i < iCell );
-        }
-        for ( i = 0; i < iCell; i++ )
-        {
-            Mio_Cell2_t * pCell = ppCells + i;
-            printf( "%4d : ", i );
-            if ( pCell->pName == NULL )
-                printf( "None\n" );
-            else
-                printf( "%-20s   In = %d   N = %3d   A = %12.6f   D = %12.6f\n", 
-                    pCell->pName, pCell->nFanins, pCounts[i], pCell->AreaF, Scl_Int2Flt(pCell->iDelayAve) );
-        }
-        ABC_FREE( pCounts );
-    }
-    if ( pnGates )
-        *pnGates = iCell;
-    return ppCells;
-}
-Mio_Cell2_t * Mio_CollectRootsNewDefault2( int nInputs, int * pnGates, int fVerbose )
-{
-    return Mio_CollectRootsNew2( (Mio_Library_t *)Abc_FrameReadLibGen(), nInputs, pnGates, fVerbose );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Derives the truth table of the gate.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Mio_CollectRootsNewDefault3( int nInputs, Vec_Ptr_t ** pvNames, Vec_Wrd_t ** pvTruths )
-{
-    Mio_Library_t * pLib = (Mio_Library_t *)Abc_FrameReadLibGen();
-    int i, iGate = 0, nGates = pLib ? Mio_LibraryReadGateNum( pLib ) : 0;
-    Mio_Gate_t * pGate0, ** ppGates; word * pTruth;
-    if ( pLib == NULL )
-        return 0;
-    ppGates = ABC_CALLOC( Mio_Gate_t *, nGates );
-    Mio_LibraryForEachGate( pLib, pGate0 )
-        ppGates[pGate0->Cell] = pGate0;
-    *pvNames  = Vec_PtrAlloc( nGates );
-    *pvTruths = Vec_WrdStart( nGates * 4 );
-    for ( i = 0; i < nGates; i++ )
-    {
-        pGate0 = ppGates[i];
-        if ( pGate0->nInputs > nInputs || pGate0->pTwin ) // skip large and multi-output
-            continue;
-        Vec_PtrPush( *pvNames, pGate0->pName );
-        pTruth = Vec_WrdEntryP( *pvTruths, iGate++*4 );
-        if ( pGate0->nInputs <= 6 )
-            pTruth[0] = pTruth[1] = pTruth[2] = pTruth[3] = pGate0->uTruth;
-        else if ( pGate0->nInputs == 7 )
-        {
-            pTruth[0] = pTruth[2] = pGate0->pTruth[0];
-            pTruth[1] = pTruth[3] = pGate0->pTruth[1];
-        }
-        else if ( pGate0->nInputs == 8 )
-            memcpy( pTruth, pGate0->pTruth, 4*sizeof(word) );
-    }
-    assert( iGate == nGates );
-    assert( Vec_WrdEntry(*pvTruths,  0) ==        0 );
-    assert( Vec_WrdEntry(*pvTruths,  4) == ~(word)0 );
-    assert( Vec_WrdEntry(*pvTruths,  8) ==  s_Truths6[0] );
-    assert( Vec_WrdEntry(*pvTruths, 12) == ~s_Truths6[0] );
-    ABC_FREE( ppGates );
-    return nGates;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Derives the truth table of the gate.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-word Mio_DeriveTruthTable6( Mio_Gate_t * pGate )
-{
-    static unsigned uTruths6[6][2] = {
-        { 0xAAAAAAAA, 0xAAAAAAAA },
-        { 0xCCCCCCCC, 0xCCCCCCCC },
-        { 0xF0F0F0F0, 0xF0F0F0F0 },
-        { 0xFF00FF00, 0xFF00FF00 },
-        { 0xFFFF0000, 0xFFFF0000 },
-        { 0x00000000, 0xFFFFFFFF }
-    };
-    union {
-      unsigned u[2];
-      word w;
-    } uTruthRes;
-    assert( pGate->nInputs <= 6 );
-    Mio_DeriveTruthTable( pGate, uTruths6, pGate->nInputs, 6, uTruthRes.u );
-    return uTruthRes.w;
-}
-
-#if 0
-
-/**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 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 );
-}
-
-#endif
-
-/**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[] )
-{
-    word uRes, uFanins[6];
-    int i;
-    assert( pGate->nInputs == nSigns );
-    for ( i = 0; i < nSigns; i++ )
-        uFanins[i] = (((word)uTruthsIn[i][1]) << 32) | (word)uTruthsIn[i][0];
-    uRes = Exp_Truth6( nSigns, pGate->vExpr, (word *)uFanins );
-    uTruthRes[0] = uRes & 0xFFFFFFFF;
-    uTruthRes[1] = uRes >> 32;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Reads the number of variables in the cover.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-int Mio_SopGetVarNum( char * pSop )
-{
-    char * pCur;
-    for ( pCur = pSop; *pCur != '\n'; pCur++ )
-        if ( *pCur == 0 )
-            return -1;
-    return pCur - pSop - 2;
-}
-
-/**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 = Mio_SopGetVarNum( pGate->pSop );
-    assert( nFanins == nInputs );
-
-    // clean the resulting truth table
-    uTruthRes[0] = 0;
-    uTruthRes[1] = 0;
-    if ( nInputs < 6 )
-    {
-//        Abc_SopForEachCube( pGate->pSop, nFanins, pCube )
-        for ( pCube = pGate->pSop; *pCube; pCube += (nFanins) + 3 )
-        {
-            // 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
-//        Abc_SopForEachCube( pGate->pSop, nFanins, pCube )
-        for ( pCube = pGate->pSop; *pCube; pCube += (nFanins) + 3 )
-        {
-            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 = ABC_ALLOC( Mio_Gate_t, 1 );
-    memset( pGate, 0, sizeof(Mio_Gate_t) );
-    pGate->nInputs = nInputs;
-    // create pins
-    for ( i = 0; i < nInputs; i++ )
-    {
-        pPin = ABC_ALLOC( Mio_Pin_t, 1 );
-        memset( pPin, 0, sizeof(Mio_Pin_t) );
-        pPin->pNext = pGate->pPins;
-        pGate->pPins = pPin;
-    }
-    return pGate;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Adds constant value to all delay values.]
-
-  Description [The pseudo-gate is a N-input gate with all info set to 0.]
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Mio_LibraryShiftDelay( Mio_Library_t * pLib, double Shift )
-{
-    Mio_Gate_t * pGate;
-    Mio_Pin_t * pPin;
-    Mio_LibraryForEachGate( pLib, pGate )
-    {
-        pGate->dDelayMax += Shift;
-        Mio_GateForEachPin( pGate, pPin )
-        {
-            pPin->dDelayBlockRise += Shift;
-            pPin->dDelayBlockFall += Shift;
-            pPin->dDelayBlockMax  += Shift;
-        }
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Multiply areas/delays by values proportional to fanin count.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Mio_LibraryMultiArea( Mio_Library_t * pLib, double Multi )
-{
-    Mio_Gate_t * pGate;
-    Mio_LibraryForEachGate( pLib, pGate )
-    {
-        if ( pGate->nInputs < 2 )
-            continue;
-//        printf( "Before %8.3f  ", pGate->dArea );
-        pGate->dArea *= pow( pGate->nInputs, Multi );
-//        printf( "After %8.3f  Inputs = %d. Factor = %8.3f\n", pGate->dArea, pGate->nInputs, pow( pGate->nInputs, Multi ) );
-    }
-}
-void Mio_LibraryMultiDelay( Mio_Library_t * pLib, double Multi )
-{
-    Mio_Gate_t * pGate;
-    Mio_Pin_t * pPin;
-    Mio_LibraryForEachGate( pLib, pGate )
-    {
-        if ( pGate->nInputs < 2 )
-            continue;
-//        printf( "Before %8.3f  ", pGate->dDelayMax );
-        pGate->dDelayMax *= pow( pGate->nInputs, Multi );
-//        printf( "After %8.3f  Inputs = %d. Factor = %8.3f\n", pGate->dDelayMax, pGate->nInputs, pow( pGate->nInputs, Multi ) );
-        Mio_GateForEachPin( pGate, pPin )
-        {
-            pPin->dDelayBlockRise *= pow( pGate->nInputs, Multi );
-            pPin->dDelayBlockFall *= pow( pGate->nInputs, Multi );
-            pPin->dDelayBlockMax  *= pow( pGate->nInputs, Multi );
-        }
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Transfers delays from the second to the first.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Mio_LibraryTransferDelays( Mio_Library_t * pLibD, Mio_Library_t * pLibS )
-{
-    Mio_Gate_t * pGateD, * pGateS;
-    Mio_Pin_t * pPinD, * pPinS;
-    Mio_LibraryForEachGate( pLibS, pGateS )
-    {
-        Mio_LibraryForEachGate( pLibD, pGateD )
-        {
-            if ( pGateD->uTruth != pGateS->uTruth )
-                continue;
-            pPinS = Mio_GateReadPins( pGateS );
-            Mio_GateForEachPin( pGateD, pPinD )
-            {
-                if (pPinS)
-                {
-                    pPinD->dDelayBlockRise = pPinS->dDelayBlockRise;
-                    pPinD->dDelayBlockFall = pPinS->dDelayBlockFall;
-                    pPinD->dDelayBlockMax  = pPinS->dDelayBlockMax;
-                    pPinS = Mio_PinReadNext(pPinS);
-                }
-                else
-                {
-                    pPinD->dDelayBlockRise = 0;
-                    pPinD->dDelayBlockFall = 0;
-                    pPinD->dDelayBlockMax  = 0;
-                }
-            }
-        }
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Nf_ManPrepareGate( int nVars, word uTruth, int * pComp, int * pPerm, Vec_Wrd_t * vResult )
-{
-    int nPerms = Extra_Factorial( nVars );
-    int nMints = (1 << nVars);
-    word tCur, tTemp1, tTemp2;
-    int i, p, c;
-    Vec_WrdClear( vResult );
-    for ( i = 0; i < 2; i++ )
-    {
-        tCur = i ? ~uTruth : uTruth;
-        tTemp1 = tCur;
-        for ( p = 0; p < nPerms; p++ )
-        {
-            tTemp2 = tCur;
-            for ( c = 0; c < nMints; c++ )
-            {
-                Vec_WrdPush( vResult, tCur );
-                tCur = Abc_Tt6Flip( tCur, pComp[c] );
-            }
-            assert( tTemp2 == tCur );
-            tCur = Abc_Tt6SwapAdjacent( tCur, pPerm[p] );
-        }
-        assert( tTemp1 == tCur );
-    }
-}
-void Nf_ManPreparePrint( int nVars, int * pComp, int * pPerm, char Line[2*720*64][8] )
-{
-    int nPerms = Extra_Factorial( nVars );
-    int nMints = (1 << nVars);
-    char * pChar, * pChar2;
-    int i, p, c, n = 0;
-    for ( i = 0; i < nVars; i++ )
-        Line[0][i] = 'A' + nVars - 1 - i;
-    Line[0][nVars] = '+';
-    Line[0][nVars+1] = 0;
-    for ( i = 0; i < 2; i++ )
-    {
-        Line[n][nVars] = i ? '-' : '+';
-        for ( p = 0; p < nPerms; p++ )
-        {
-            for ( c = 0; c < nMints; c++ )
-            {
-                strcpy( Line[n+1], Line[n] ); n++;
-                pChar = &Line[n][pComp[c]];
-                if ( *pChar >= 'A' && *pChar <= 'Z' )
-                    *pChar += 'a' - 'A';
-                else if ( *pChar >= 'a' && *pChar <= 'z' )
-                    *pChar -= 'a' - 'A';
-            }
-            pChar  = &Line[n][pPerm[p]];
-            pChar2 = pChar + 1;
-            ABC_SWAP( char, *pChar, *pChar2 );
-        }
-    }
-    assert( n == 2*nPerms*nMints );
-    n = 0;
-    for ( i = 0; i < 2; i++ )
-        for ( p = 0; p < nPerms; p++ )
-            for ( c = 0; c < nMints; c++ )
-                printf("%8d : %d %3d %2d : %s\n", n, i, p, c, Line[n]), n++;
-}
-
-void Nf_ManPrepareLibrary( Mio_Library_t * pLib )
-{
-//    char Lines[2*720*64][8];
-//    Nf_ManPreparePrint( 6, pComp, pPerm, Lines );
-    int * pComp[7];
-    int * pPerm[7];
-    Mio_Gate_t ** ppGates;
-    Vec_Wrd_t * vResult;
-    word * pTruths;
-    int * pSizes;
-    int nGates, i, nClasses = 0, nTotal;
-    abctime clk = Abc_Clock();
-
-    for ( i = 2; i <= 6; i++ )
-        pComp[i] = Extra_GreyCodeSchedule( i );
-    for ( i = 2; i <= 6; i++ )
-        pPerm[i] = Extra_PermSchedule( i );
-
-    // collect truth tables
-    ppGates = Mio_CollectRoots( pLib, 6, (float)1.0e+20, 1, &nGates, 0 );
-    pSizes  = ABC_CALLOC( int, nGates );
-    pTruths = ABC_CALLOC( word, nGates );
-    vResult = Vec_WrdAlloc( 2 * 720 * 64 );
-    for ( i = 0; i < nGates; i++ )
-    {
-        pSizes[i] = Mio_GateReadPinNum( ppGates[i] );
-        assert( pSizes[i] > 1 && pSizes[i] <= 6 );
-        pTruths[i] = Mio_GateReadTruth( ppGates[i] );
-
-        Nf_ManPrepareGate( pSizes[i], pTruths[i], pComp[pSizes[i]], pPerm[pSizes[i]], vResult );
-        Vec_WrdUniqify(vResult);
-        nClasses += Vec_WrdSize(vResult);
-        nTotal = (1 << (pSizes[i]+1)) * Extra_Factorial(pSizes[i]);
-
-        printf( "%6d : ", i );
-        printf( "%16s : ", Mio_GateReadName( ppGates[i] ) );
-        printf( "%48s : ", Mio_GateReadForm( ppGates[i] ) );
-        printf( "Inputs = %2d   ", pSizes[i] );
-        printf( "Total = %6d  ", nTotal );
-        printf( "Classes = %6d ", Vec_WrdSize(vResult) );
-        printf( "Configs = %8.2f ", 1.0*nTotal/Vec_WrdSize(vResult) );
-        printf( "%6.2f %%  ", 100.0*Vec_WrdSize(vResult)/nTotal );
-        Dau_DsdPrintFromTruth( &pTruths[i], pSizes[i] );
-//        printf( "\n" );
-    }
-    Vec_WrdFree( vResult );
-    ABC_FREE( ppGates );
-    ABC_FREE( pSizes );
-    ABC_FREE( pTruths );
-
-    for ( i = 2; i <= 6; i++ )
-        ABC_FREE( pComp[i] );
-    for ( i = 2; i <= 6; i++ )
-        ABC_FREE( pPerm[i] );
-
-    printf( "Classes = %d.  ", nClasses );
-    Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
-}
-
-void Nf_ManPrepareLibraryTest2()
-{
-    Mio_Library_t * pLib = (Mio_Library_t *)Abc_FrameReadLibGen();
-    if ( pLib != NULL )
-        Nf_ManPrepareLibrary( pLib );
-    else
-        printf( "Standard cell library is not available.\n" );
-
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Install library.]
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Mio_LibraryTransferCellIds()
-{
-    Mio_Gate_t * pGate;
-    Mio_Library_t * pLib = (Mio_Library_t *)Abc_FrameReadLibGen();
-    SC_Lib * pScl = (SC_Lib *)Abc_FrameReadLibScl();
-    int CellId;
-    if ( pScl == NULL )
-    {
-        printf( "SC library cannot be found.\n" );
-        return;
-    }
-    if ( pLib == NULL )
-    {
-        printf( "Genlib library cannot be found.\n" );
-        return;
-    }
-    Mio_LibraryForEachGate( pLib, pGate )
-    {
-        if ( Mio_GateReadPinNum(pGate) == 0 )
-            continue;
-        CellId = Abc_SclCellFind( pScl, Mio_GateReadName(pGate) );
-        if ( CellId < 0 )
-            printf( "Cannot find cell ID of gate %s.\n", Mio_GateReadName(pGate) );
-        else
-            Mio_GateSetCell( pGate, CellId );
-    }
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Mio_LibraryReadProfile( FILE * pFile, Mio_Library_t * pLib )
-{
-    Mio_Gate_t * pGate;    
-    char pBuffer[1000];
-    while ( fgets( pBuffer, 1000, pFile ) != NULL )
-    {
-        char * pToken = strtok( pBuffer, " \t\n" );
-        if ( pToken == NULL )
-            continue;
-        if ( pToken[0] == '#' )
-            continue;
-        // read gate
-        pGate = Mio_LibraryReadGateByName( pLib, pToken, NULL );
-        if ( pGate == NULL )
-        {
-            printf( "Cannot find gate \"%s\" in library \"%s\".\n", pToken, Mio_LibraryReadName(pLib) );
-            continue;
-        }
-        // read profile
-        pToken = strtok( NULL, " \t\n" );
-        Mio_GateSetProfile( pGate, atoi(pToken) );
-    }
-}
-
-void Mio_LibraryWriteProfile( FILE * pFile, Mio_Library_t * pLib )
-{
-    Mio_Gate_t * pGate;    
-    Mio_LibraryForEachGate( pLib, pGate )
-        if ( Mio_GateReadProfile(pGate) > 0 )
-            fprintf( pFile, "%-24s  %6d\n", Mio_GateReadName(pGate), Mio_GateReadProfile(pGate) );
-}
-
-int Mio_LibraryHasProfile( Mio_Library_t * pLib )
-{
-    Mio_Gate_t * pGate;    
-    Mio_LibraryForEachGate( pLib, pGate )
-        if ( Mio_GateReadProfile(pGate) > 0 )
-            return 1;
-    return 0;
-}
-
-
-void Mio_LibraryTransferProfile( Mio_Library_t * pLibDst, Mio_Library_t * pLibSrc )
-{
-    Mio_Gate_t * pGateSrc, * pGateDst;    
-    Mio_LibraryForEachGate( pLibDst, pGateDst )
-        Mio_GateSetProfile( pGateDst, 0 );
-    Mio_LibraryForEachGate( pLibSrc, pGateSrc )
-        if ( Mio_GateReadProfile(pGateSrc) > 0 )
-        {
-            // find gate by name
-            pGateDst = Mio_LibraryReadGateByName( pLibDst, Mio_GateReadName(pGateSrc), NULL );
-            if ( pGateDst == NULL )
-            {
-                // find gate by function
-                Mio_LibraryForEachGate( pLibDst, pGateDst )
-                    if ( pGateDst->uTruth == pGateSrc->uTruth )
-                        break;
-                if ( pGateDst == NULL )
-                {
-                    printf( "Cannot find gate \"%s\" in library \"%s\".\n", Mio_GateReadName(pGateSrc), Mio_LibraryReadName(pLibDst) );
-                    continue;
-                }
-            }
-            Mio_GateAddToProfile( pGateDst, Mio_GateReadProfile(pGateSrc) );
-        }
-}
-void Mio_LibraryTransferProfile2( Mio_Library_t * pLibDst, Mio_Library_t * pLibSrc )
-{
-    Mio_Gate_t * pGateSrc, * pGateDst;    
-    Mio_LibraryForEachGate( pLibDst, pGateDst )
-        Mio_GateSetProfile2( pGateDst, 0 );
-    Mio_LibraryForEachGate( pLibSrc, pGateSrc )
-        if ( Mio_GateReadProfile2(pGateSrc) > 0 )
-        {
-            // find gate by name
-            pGateDst = Mio_LibraryReadGateByName( pLibDst, Mio_GateReadName(pGateSrc), NULL );
-            if ( pGateDst == NULL )
-            {
-                // find gate by function
-                Mio_LibraryForEachGate( pLibDst, pGateDst )
-                    if ( pGateDst->uTruth == pGateSrc->uTruth )
-                        break;
-                if ( pGateDst == NULL )
-                {
-                    printf( "Cannot find gate \"%s\" in library \"%s\".\n", Mio_GateReadName(pGateSrc), Mio_LibraryReadName(pLibDst) );
-                    continue;
-                }
-            }
-            Mio_GateAddToProfile2( pGateDst, Mio_GateReadProfile2(pGateSrc) );
-        }
-}
-
-void Mio_LibraryCleanProfile2( Mio_Library_t * pLib )
-{
-    Mio_Gate_t * pGate;    
-    Mio_LibraryForEachGate( pLib, pGate )
-        Mio_GateSetProfile2( pGate, 0 );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Mio_LibraryHashGates( Mio_Library_t * pLib )
-{
-    Mio_Gate_t * pGate;    
-    Mio_LibraryForEachGate( pLib, pGate )
-        if ( pGate->pTwin )
-        {
-            printf( "Gates with multiple outputs are not supported.\n" );
-            return;
-        }
-    if ( pLib->tName2Gate )
-        st__free_table( pLib->tName2Gate );
-    pLib->tName2Gate = st__init_table(strcmp, st__strhash);
-    Mio_LibraryForEachGate( pLib, pGate )
-        st__insert( pLib->tName2Gate, pGate->pName, (char *)pGate );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-static inline int Abc_SclIsChar( char c )
-{
-    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_';
-}
-static inline int Abc_SclIsName( char c )
-{
-    return Abc_SclIsChar(c) || (c >= '0' && c <= '9');
-}
-static inline char * Abc_SclFindLimit( char * pName )
-{
-    assert( Abc_SclIsChar(*pName) );
-    while ( Abc_SclIsName(*pName) )
-        pName++;
-    return pName;
-}
-static inline int Abc_SclAreEqual( char * pBase, char * pName, char * pLimit )
-{
-    return !strncmp( pBase, pName, pLimit - pName );
-}
-void Mio_LibraryShortFormula( Mio_Gate_t * pCell, char * pForm, char * pBuffer )
-{
-    Mio_Pin_t * pPin; 
-    char * pTemp, * pLimit; int i;
-    if ( !strncmp(pForm, "CONST", 5) )
-    {
-        sprintf( pBuffer, "%s", pForm );
-        return;
-    }
-    for ( pTemp = pForm; *pTemp; )
-    {
-        if ( !Abc_SclIsChar(*pTemp) )
-        {
-            *pBuffer++ = *pTemp++;
-            continue;
-        }
-        pLimit = Abc_SclFindLimit( pTemp );
-        i = 0;
-        Mio_GateForEachPin( pCell, pPin )
-        {
-            if ( Abc_SclAreEqual( pPin->pName, pTemp, pLimit ) )
-            {
-                *pBuffer++ = 'a' + i;
-                break;
-            }
-            i++;
-        }
-        pTemp = pLimit;
-    }
-    *pBuffer++ = 0;
-}
-void Mio_LibraryShortNames( Mio_Library_t * pLib )
-{
-    char Buffer[10000];
-    Mio_Gate_t * pGate; Mio_Pin_t * pPin;
-    int c = 0, i, nDigits = Abc_Base10Log( Mio_LibraryReadGateNum(pLib) );
-    // itereate through classes
-    Mio_LibraryForEachGate( pLib, pGate )
-    {
-        ABC_FREE( pGate->pName );
-        sprintf( Buffer, "g%0*d", nDigits, ++c );
-        pGate->pName = Abc_UtilStrsav( Buffer );
-        // update formula
-        Mio_LibraryShortFormula( pGate, pGate->pForm, Buffer );
-        ABC_FREE( pGate->pForm );
-        pGate->pForm = Abc_UtilStrsav( Buffer );
-        // pin names
-        i = 0;
-        Mio_GateForEachPin( pGate, pPin )
-        {
-            ABC_FREE( pPin->pName );
-            sprintf( Buffer, "%c", 'a'+i );
-            pPin->pName = Abc_UtilStrsav( Buffer );
-            i++;
-        }
-        // output pin
-        ABC_FREE( pGate->pOutName );
-        sprintf( Buffer, "z" );
-        pGate->pOutName = Abc_UtilStrsav( Buffer );
-    }
-    Mio_LibraryHashGates( pLib );
-    // update library name
-    printf( "Renaming library \"%s\" into \"%s%d\".\n", pLib->pName, "lib", Mio_LibraryReadGateNum(pLib) );
-    ABC_FREE( pLib->pName );
-    sprintf( Buffer, "lib%d", Mio_LibraryReadGateNum(pLib) );
-    pLib->pName = Abc_UtilStrsav( Buffer );
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Mio_LibraryMatchesStop( Mio_Library_t * pLib )
-{
-    if ( !pLib->vTtMem )
-        return;
-    Vec_WecFree( pLib->vTt2Match );
-    Vec_MemHashFree( pLib->vTtMem );
-    Vec_MemFree( pLib->vTtMem );
-    ABC_FREE( pLib->pCells );
-}
-void Mio_LibraryMatchesStart( Mio_Library_t * pLib, int fPinFilter, int fPinPerm, int fPinQuick )
-{
-    extern Mio_Cell2_t * Nf_StoDeriveMatches( Vec_Mem_t * vTtMem, Vec_Wec_t * vTt2Match, int * pnCells, int fPinFilter, int fPinPerm, int fPinQuick );
-    if ( pLib->vTtMem && pLib->fPinFilter == fPinFilter && pLib->fPinPerm == fPinPerm && pLib->fPinQuick == fPinQuick )
-        return;
-    if ( pLib->vTtMem )
-        Mio_LibraryMatchesStop( pLib );
-    pLib->fPinFilter = fPinFilter;  // pin filtering
-    pLib->fPinPerm   = fPinPerm;    // pin permutation
-    pLib->fPinQuick  = fPinQuick;   // pin permutation
-    pLib->vTtMem     = Vec_MemAllocForTT( 6, 0 );          
-    pLib->vTt2Match  = Vec_WecAlloc( 1000 ); 
-    Vec_WecPushLevel( pLib->vTt2Match );
-    Vec_WecPushLevel( pLib->vTt2Match );
-    assert( Vec_WecSize(pLib->vTt2Match) == Vec_MemEntryNum(pLib->vTtMem) );
-    pLib->pCells = Nf_StoDeriveMatches( pLib->vTtMem, pLib->vTt2Match, &pLib->nCells, fPinFilter, fPinPerm, fPinQuick );
-}
-void Mio_LibraryMatchesFetch( Mio_Library_t * pLib, Vec_Mem_t ** pvTtMem, Vec_Wec_t ** pvTt2Match, Mio_Cell2_t ** ppCells, int * pnCells, int fPinFilter, int fPinPerm, int fPinQuick )
-{
-    Mio_LibraryMatchesStart( pLib, fPinFilter, fPinPerm, fPinQuick );
-    *pvTtMem    = pLib->vTtMem;     // truth tables
-    *pvTt2Match = pLib->vTt2Match;  // matches for truth tables
-    *ppCells    = pLib->pCells;     // library gates
-    *pnCells    = pLib->nCells;     // library gate count
-}
-
-/**Function*************************************************************
-
-  Synopsis    []
-
-  Description []
-               
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Mio_LibraryMatches2Stop( Mio_Library_t * pLib )
-{
-    int i;
-    if ( !pLib->vNames )
-        return;
-    Vec_PtrFree( pLib->vNames );
-    Vec_WrdFree( pLib->vTruths );
-    Vec_IntFree( pLib->vTt2Match4 );
-    Vec_IntFree( pLib->vConfigs );
-    for ( i = 0; i < 3; i++ )
-    {
-        Vec_MemHashFree( pLib->vTtMem2[i] );
-        Vec_MemFree( pLib->vTtMem2[i] );
-        Vec_IntFree( pLib->vTt2Match2[i] );
-    }
-}
-void Mio_LibraryMatches2Start( Mio_Library_t * pLib )
-{
-    extern int Gia_ManDeriveMatches( Vec_Ptr_t ** pvNames, Vec_Wrd_t ** pvTruths, Vec_Int_t ** pvTt2Match4, Vec_Int_t ** pvConfigs, Vec_Mem_t * pvTtMem2[3], Vec_Int_t * pvTt2Match2[3] );
-    if ( pLib->vNames )
-        return;
-    if ( pLib->vTtMem )
-        Mio_LibraryMatches2Stop( pLib );
-    Gia_ManDeriveMatches( &pLib->vNames, &pLib->vTruths, &pLib->vTt2Match4, &pLib->vConfigs, pLib->vTtMem2, pLib->vTt2Match2 );
-}
-void Mio_LibraryMatches2Fetch( Mio_Library_t * pLib, Vec_Ptr_t ** pvNames, Vec_Wrd_t ** pvTruths, Vec_Int_t ** pvTt2Match4, Vec_Int_t ** pvConfigs, Vec_Mem_t * pvTtMem2[3], Vec_Int_t * pvTt2Match2[3] )
-{
-    int i;
-    Mio_LibraryMatches2Start( pLib );
-    *pvNames     = pLib->vNames;    
-    *pvTruths    = pLib->vTruths;    
-    *pvTt2Match4 = pLib->vTt2Match4;    
-    *pvConfigs   = pLib->vConfigs;    
-    for ( i = 0; i < 3; i++ )
-    {
-        pvTtMem2[i]  = pLib->vTtMem2[i];    
-        pvTt2Match2[i] = pLib->vTt2Match2[i];   
-    }
-}
-
-////////////////////////////////////////////////////////////////////////
-///                       END OF FILE                                ///
-////////////////////////////////////////////////////////////////////////
-
-
-ABC_NAMESPACE_IMPL_END
-